@lampdotdev/lamp 0.0.0-stage → 0.35.0

package/Resources/WebLibraries/three/addons/shaders/SepiaShader.js

@@ -0,0 +1,57 @@
+/**
+ * @module SepiaShader
+ * @three_import import { SepiaShader } from 'three/addons/shaders/SepiaShader.js';
+ */
+
+/**
+ * Sepia tone shader based on [glfx.js sepia shader](https://github.com/evanw/glfx.js).
+ *
+ * @constant
+ * @type {ShaderMaterial~Shader}
+ */
+const SepiaShader = {
+
+	name: 'SepiaShader',
+
+	uniforms: {
+
+		'tDiffuse': { value: null },
+		'amount': { value: 1.0 }
+
+	},
+
+	vertexShader: /* glsl */`
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}`,
+
+	fragmentShader: /* glsl */`
+
+		uniform float amount;
+
+		uniform sampler2D tDiffuse;
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vec4 color = texture2D( tDiffuse, vUv );
+			vec3 c = color.rgb;
+
+			color.r = dot( c, vec3( 1.0 - 0.607 * amount, 0.769 * amount, 0.189 * amount ) );
+			color.g = dot( c, vec3( 0.349 * amount, 1.0 - 0.314 * amount, 0.168 * amount ) );
+			color.b = dot( c, vec3( 0.272 * amount, 0.534 * amount, 1.0 - 0.869 * amount ) );
+
+			gl_FragColor = vec4( min( vec3( 1.0 ), color.rgb ), color.a );
+
+		}`
+
+};
+
+export { SepiaShader };

package/Resources/WebLibraries/three/addons/shaders/SobelOperatorShader.js

@@ -0,0 +1,98 @@
+import {
+	Vector2
+} from 'three';
+
+/**
+ * @module SobelOperatorShader
+ * @three_import import { SobelOperatorShader } from 'three/addons/shaders/SobelOperatorShader.js';
+ */
+
+/**
+ * Sobel Edge Detection (see {@link https://youtu.be/uihBwtPIBxM}).
+ *
+ * As mentioned in the video the Sobel operator expects a grayscale image as input.
+ *
+ * @constant
+ * @type {ShaderMaterial~Shader}
+ */
+const SobelOperatorShader = {
+
+	name: 'SobelOperatorShader',
+
+	uniforms: {
+
+		'tDiffuse': { value: null },
+		'resolution': { value: new Vector2() }
+
+	},
+
+	vertexShader: /* glsl */`
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}`,
+
+	fragmentShader: /* glsl */`
+
+		uniform sampler2D tDiffuse;
+		uniform vec2 resolution;
+		varying vec2 vUv;
+
+		void main() {
+
+			vec2 texel = vec2( 1.0 / resolution.x, 1.0 / resolution.y );
+
+		// kernel definition (in glsl matrices are filled in column-major order)
+
+			const mat3 Gx = mat3( -1, -2, -1, 0, 0, 0, 1, 2, 1 ); // x direction kernel
+			const mat3 Gy = mat3( -1, 0, 1, -2, 0, 2, -1, 0, 1 ); // y direction kernel
+
+		// fetch the 3x3 neighbourhood of a fragment
+
+		// first column
+
+			float tx0y0 = texture2D( tDiffuse, vUv + texel * vec2( -1, -1 ) ).r;
+			float tx0y1 = texture2D( tDiffuse, vUv + texel * vec2( -1,  0 ) ).r;
+			float tx0y2 = texture2D( tDiffuse, vUv + texel * vec2( -1,  1 ) ).r;
+
+		// second column
+
+			float tx1y0 = texture2D( tDiffuse, vUv + texel * vec2(  0, -1 ) ).r;
+			float tx1y1 = texture2D( tDiffuse, vUv + texel * vec2(  0,  0 ) ).r;
+			float tx1y2 = texture2D( tDiffuse, vUv + texel * vec2(  0,  1 ) ).r;
+
+		// third column
+
+			float tx2y0 = texture2D( tDiffuse, vUv + texel * vec2(  1, -1 ) ).r;
+			float tx2y1 = texture2D( tDiffuse, vUv + texel * vec2(  1,  0 ) ).r;
+			float tx2y2 = texture2D( tDiffuse, vUv + texel * vec2(  1,  1 ) ).r;
+
+		// gradient value in x direction
+
+			float valueGx = Gx[0][0] * tx0y0 + Gx[1][0] * tx1y0 + Gx[2][0] * tx2y0 +
+				Gx[0][1] * tx0y1 + Gx[1][1] * tx1y1 + Gx[2][1] * tx2y1 +
+				Gx[0][2] * tx0y2 + Gx[1][2] * tx1y2 + Gx[2][2] * tx2y2;
+
+		// gradient value in y direction
+
+			float valueGy = Gy[0][0] * tx0y0 + Gy[1][0] * tx1y0 + Gy[2][0] * tx2y0 +
+				Gy[0][1] * tx0y1 + Gy[1][1] * tx1y1 + Gy[2][1] * tx2y1 +
+				Gy[0][2] * tx0y2 + Gy[1][2] * tx1y2 + Gy[2][2] * tx2y2;
+
+		// magnitude of the total gradient
+
+			float G = sqrt( ( valueGx * valueGx ) + ( valueGy * valueGy ) );
+
+			gl_FragColor = vec4( vec3( G ), 1 );
+
+		}`
+
+};
+
+export { SobelOperatorShader };

package/Resources/WebLibraries/three/addons/shaders/SubsurfaceScatteringShader.js

@@ -0,0 +1,95 @@
+import {
+	Color,
+	ShaderChunk,
+	ShaderLib,
+	UniformsUtils
+} from 'three';
+
+function replaceAll( string, find, replace ) {
+
+	return string.split( find ).join( replace );
+
+}
+
+const meshphong_frag_head = ShaderChunk[ 'meshphong_frag' ].slice( 0, ShaderChunk[ 'meshphong_frag' ].indexOf( 'void main() {' ) );
+const meshphong_frag_body = ShaderChunk[ 'meshphong_frag' ].slice( ShaderChunk[ 'meshphong_frag' ].indexOf( 'void main() {' ) );
+
+/**
+ * @module SubsurfaceScatteringShader
+ * @three_import import { SubsurfaceScatteringShader } from 'three/addons/shaders/SubsurfaceScatteringShader.js';
+ */
+
+/**
+ * Subsurface Scattering shader.
+ *
+ * Based on GDC 2011 – [Approximating Translucency for a Fast, Cheap and Convincing Subsurface Scattering Look](https://colinbarrebrisebois.com/2011/03/07/gdc-2011-approximating-translucency-for-a-fast-cheap-and-convincing-subsurface-scattering-look/)
+ *
+ * @constant
+ * @type {ShaderMaterial~Shader}
+ */
+const SubsurfaceScatteringShader = {
+
+	name: 'SubsurfaceScatteringShader',
+
+	uniforms: UniformsUtils.merge( [
+		ShaderLib[ 'phong' ].uniforms,
+		{
+			'thicknessMap': { value: null },
+			'thicknessColor': { value: new Color( 0xffffff ) },
+			'thicknessDistortion': { value: 0.1 },
+			'thicknessAmbient': { value: 0.0 },
+			'thicknessAttenuation': { value: 0.1 },
+			'thicknessPower': { value: 2.0 },
+			'thicknessScale': { value: 10.0 }
+		}
+
+	] ),
+
+	vertexShader: [
+		'#define USE_UV',
+		ShaderChunk[ 'meshphong_vert' ],
+	].join( '\n' ),
+
+	fragmentShader: [
+		'#define USE_UV',
+		'#define SUBSURFACE',
+
+		meshphong_frag_head,
+
+		'uniform sampler2D thicknessMap;',
+		'uniform float thicknessPower;',
+		'uniform float thicknessScale;',
+		'uniform float thicknessDistortion;',
+		'uniform float thicknessAmbient;',
+		'uniform float thicknessAttenuation;',
+		'uniform vec3 thicknessColor;',
+
+		'void RE_Direct_Scattering(const in IncidentLight directLight, const in vec2 uv, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, inout ReflectedLight reflectedLight) {',
+		'	vec3 thickness = thicknessColor * texture2D(thicknessMap, uv).r;',
+		'	vec3 scatteringHalf = normalize(directLight.direction + (geometryNormal * thicknessDistortion));',
+		'	float scatteringDot = pow(saturate(dot(geometryViewDir, -scatteringHalf)), thicknessPower) * thicknessScale;',
+		'	vec3 scatteringIllu = (scatteringDot + thicknessAmbient) * thickness;',
+		'	reflectedLight.directDiffuse += scatteringIllu * thicknessAttenuation * directLight.color;',
+		'}',
+
+		meshphong_frag_body.replace( '#include <lights_fragment_begin>',
+
+			replaceAll(
+				ShaderChunk[ 'lights_fragment_begin' ],
+				'RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );',
+				[
+					'RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );',
+
+					'#if defined( SUBSURFACE ) && defined( USE_UV )',
+					' RE_Direct_Scattering(directLight, vUv, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, reflectedLight);',
+					'#endif',
+				].join( '\n' )
+			),
+
+		),
+
+	].join( '\n' ),
+
+};
+
+export { SubsurfaceScatteringShader };

package/Resources/WebLibraries/three/addons/shaders/TechnicolorShader.js

@@ -0,0 +1,51 @@
+/**
+ * @module TriangleBlurShader
+ * @three_import import { TriangleBlurShader } from 'three/addons/shaders/TriangleBlurShader.js';
+ */
+
+/**
+ * Simulates the look of the two-strip technicolor process popular in early 20th century films.
+ * More historical info here: {@link http://www.widescreenmuseum.com/oldcolor/technicolor1.htm}
+ * Demo here: {@link http://charliehoey.com/technicolor_shader/shader_test.html}
+ *
+ * @constant
+ * @type {ShaderMaterial~Shader}
+ */
+const TechnicolorShader = {
+
+	name: 'TechnicolorShader',
+
+	uniforms: {
+
+		'tDiffuse': { value: null }
+
+	},
+
+	vertexShader: /* glsl */`
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}`,
+
+	fragmentShader: /* glsl */`
+
+		uniform sampler2D tDiffuse;
+		varying vec2 vUv;
+
+		void main() {
+
+			vec4 tex = texture2D( tDiffuse, vec2( vUv.x, vUv.y ) );
+			vec4 newTex = vec4(tex.r, (tex.g + tex.b) * .5, (tex.g + tex.b) * .5, 1.0);
+
+			gl_FragColor = newTex;
+
+		}`
+
+};
+
+export { TechnicolorShader };

package/Resources/WebLibraries/three/addons/shaders/ToonShader.js

@@ -0,0 +1,349 @@
+import {
+	Color,
+	Vector3
+} from 'three';
+
+/**
+ * Collection of toon shaders.
+ *
+ * @module TriangleBlurShader
+ * @three_import import * as ToonShader from 'three/addons/shaders/ToonShader.js';
+ */
+
+/**
+ * Toon1 shader.
+ *
+ * @constant
+ * @type {ShaderMaterial~Shader}
+ */
+const ToonShader1 = {
+
+	name: 'ToonShader1',
+
+	uniforms: {
+
+		'uDirLightPos': { value: new Vector3() },
+		'uDirLightColor': { value: new Color( 0xeeeeee ) },
+
+		'uAmbientLightColor': { value: new Color( 0x050505 ) },
+
+		'uBaseColor': { value: new Color( 0xffffff ) }
+
+	},
+
+	vertexShader: /* glsl */`
+
+		varying vec3 vNormal;
+		varying vec3 vRefract;
+
+		void main() {
+
+			vec4 worldPosition = modelMatrix * vec4( position, 1.0 );
+			vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
+			vec3 worldNormal = normalize ( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );
+
+			vNormal = normalize( normalMatrix * normal );
+
+			vec3 I = worldPosition.xyz - cameraPosition;
+			vRefract = refract( normalize( I ), worldNormal, 1.02 );
+
+			gl_Position = projectionMatrix * mvPosition;
+
+		}`,
+
+	fragmentShader: /* glsl */`
+
+		uniform vec3 uBaseColor;
+
+		uniform vec3 uDirLightPos;
+		uniform vec3 uDirLightColor;
+
+		uniform vec3 uAmbientLightColor;
+
+		varying vec3 vNormal;
+
+		varying vec3 vRefract;
+
+		void main() {
+
+			float directionalLightWeighting = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);
+			vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;
+
+			float intensity = smoothstep( - 0.5, 1.0, pow( length(lightWeighting), 20.0 ) );
+			intensity += length(lightWeighting) * 0.2;
+
+			float cameraWeighting = dot( normalize( vNormal ), vRefract );
+			intensity += pow( 1.0 - length( cameraWeighting ), 6.0 );
+			intensity = intensity * 0.2 + 0.3;
+
+			if ( intensity < 0.50 ) {
+
+				gl_FragColor = vec4( 2.0 * intensity * uBaseColor, 1.0 );
+
+			} else {
+
+				gl_FragColor = vec4( 1.0 - 2.0 * ( 1.0 - intensity ) * ( 1.0 - uBaseColor ), 1.0 );
+
+			}
+
+			#include <colorspace_fragment>
+
+		}`
+
+};
+/**
+ * Toon2 shader.
+ *
+ * @constant
+ * @type {Object}
+ */
+const ToonShader2 = {
+
+	uniforms: {
+
+		'uDirLightPos': { value: new Vector3() },
+		'uDirLightColor': { value: new Color( 0xeeeeee ) },
+
+		'uAmbientLightColor': { value: new Color( 0x050505 ) },
+
+		'uBaseColor': { value: new Color( 0xeeeeee ) },
+		'uLineColor1': { value: new Color( 0x808080 ) },
+		'uLineColor2': { value: new Color( 0x000000 ) },
+		'uLineColor3': { value: new Color( 0x000000 ) },
+		'uLineColor4': { value: new Color( 0x000000 ) }
+
+	},
+
+	vertexShader: /* glsl */`
+
+		varying vec3 vNormal;
+
+		void main() {
+
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+			vNormal = normalize( normalMatrix * normal );
+
+		}`,
+
+	fragmentShader: /* glsl */`
+
+		uniform vec3 uBaseColor;
+		uniform vec3 uLineColor1;
+		uniform vec3 uLineColor2;
+		uniform vec3 uLineColor3;
+		uniform vec3 uLineColor4;
+
+		uniform vec3 uDirLightPos;
+		uniform vec3 uDirLightColor;
+
+		uniform vec3 uAmbientLightColor;
+
+		varying vec3 vNormal;
+
+		void main() {
+
+			float camera = max( dot( normalize( vNormal ), vec3( 0.0, 0.0, 1.0 ) ), 0.4);
+			float light = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);
+
+			gl_FragColor = vec4( uBaseColor, 1.0 );
+
+			if ( length(uAmbientLightColor + uDirLightColor * light) < 1.00 ) {
+
+				gl_FragColor *= vec4( uLineColor1, 1.0 );
+
+			}
+
+			if ( length(uAmbientLightColor + uDirLightColor * camera) < 0.50 ) {
+
+				gl_FragColor *= vec4( uLineColor2, 1.0 );
+
+			}
+
+			#include <colorspace_fragment>
+
+		}`
+
+};
+
+/**
+ * Toon Hatching shader.
+ *
+ * @constant
+ * @type {Object}
+ */
+const ToonShaderHatching = {
+
+	uniforms: {
+
+		'uDirLightPos':	{ value: new Vector3() },
+		'uDirLightColor': { value: new Color( 0xeeeeee ) },
+
+		'uAmbientLightColor': { value: new Color( 0x050505 ) },
+
+		'uBaseColor': { value: new Color( 0xffffff ) },
+		'uLineColor1': { value: new Color( 0x000000 ) },
+		'uLineColor2': { value: new Color( 0x000000 ) },
+		'uLineColor3': { value: new Color( 0x000000 ) },
+		'uLineColor4': { value: new Color( 0x000000 ) }
+
+	},
+
+	vertexShader: /* glsl */`
+
+		varying vec3 vNormal;
+
+		void main() {
+
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+			vNormal = normalize( normalMatrix * normal );
+
+		}`,
+
+	fragmentShader: /* glsl */`
+
+		uniform vec3 uBaseColor;
+		uniform vec3 uLineColor1;
+		uniform vec3 uLineColor2;
+		uniform vec3 uLineColor3;
+		uniform vec3 uLineColor4;
+
+		uniform vec3 uDirLightPos;
+		uniform vec3 uDirLightColor;
+
+		uniform vec3 uAmbientLightColor;
+
+		varying vec3 vNormal;
+
+		void main() {
+
+			float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);
+			vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;
+
+			gl_FragColor = vec4( uBaseColor, 1.0 );
+
+			if ( length(lightWeighting) < 1.00 ) {
+
+				if ( mod(gl_FragCoord.x + gl_FragCoord.y, 10.0) == 0.0) {
+
+					gl_FragColor = vec4( uLineColor1, 1.0 );
+
+				}
+
+			}
+
+			if ( length(lightWeighting) < 0.75 ) {
+
+				if (mod(gl_FragCoord.x - gl_FragCoord.y, 10.0) == 0.0) {
+
+					gl_FragColor = vec4( uLineColor2, 1.0 );
+
+				}
+
+			}
+
+			if ( length(lightWeighting) < 0.50 ) {
+
+				if (mod(gl_FragCoord.x + gl_FragCoord.y - 5.0, 10.0) == 0.0) {
+
+					gl_FragColor = vec4( uLineColor3, 1.0 );
+
+				}
+
+			}
+
+			if ( length(lightWeighting) < 0.3465 ) {
+
+				if (mod(gl_FragCoord.x - gl_FragCoord.y - 5.0, 10.0) == 0.0) {
+
+					gl_FragColor = vec4( uLineColor4, 1.0 );
+
+			}
+
+			}
+
+			#include <colorspace_fragment>
+
+		}`
+
+};
+
+/**
+ * Toon Dotted shader.
+ *
+ * @constant
+ * @type {Object}
+ */
+const ToonShaderDotted = {
+
+	uniforms: {
+
+		'uDirLightPos':	{ value: new Vector3() },
+		'uDirLightColor': { value: new Color( 0xeeeeee ) },
+
+		'uAmbientLightColor': { value: new Color( 0x050505 ) },
+
+		'uBaseColor': { value: new Color( 0xffffff ) },
+		'uLineColor1': { value: new Color( 0x000000 ) }
+
+	},
+
+	vertexShader: /* glsl */`
+
+		varying vec3 vNormal;
+
+		void main() {
+
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+			vNormal = normalize( normalMatrix * normal );
+
+		}`,
+
+	fragmentShader: /* glsl */`
+
+		uniform vec3 uBaseColor;
+		uniform vec3 uLineColor1;
+		uniform vec3 uLineColor2;
+		uniform vec3 uLineColor3;
+		uniform vec3 uLineColor4;
+
+		uniform vec3 uDirLightPos;
+		uniform vec3 uDirLightColor;
+
+		uniform vec3 uAmbientLightColor;
+
+		varying vec3 vNormal;
+
+		void main() {
+
+			float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);
+			vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;
+
+			gl_FragColor = vec4( uBaseColor, 1.0 );
+
+			if ( length(lightWeighting) < 1.00 ) {
+
+				if ( ( mod(gl_FragCoord.x, 4.001) + mod(gl_FragCoord.y, 4.0) ) > 6.00 ) {
+
+					gl_FragColor = vec4( uLineColor1, 1.0 );
+
+				}
+
+			}
+
+			if ( length(lightWeighting) < 0.50 ) {
+
+				if ( ( mod(gl_FragCoord.x + 2.0, 4.001) + mod(gl_FragCoord.y + 2.0, 4.0) ) > 6.00 ) {
+
+					gl_FragColor = vec4( uLineColor1, 1.0 );
+
+				}
+
+			}
+
+			#include <colorspace_fragment>
+
+		}`
+
+};
+
+export { ToonShader1, ToonShader2, ToonShaderHatching, ToonShaderDotted };