@needle-tools/three 0.145.0

package/src/renderers/shaders/ShaderChunk/tonemapping_pars_fragment.glsl.js

@@ -0,0 +1,77 @@
+export default /* glsl */`
+#ifndef saturate
+// <common> may have defined saturate() already
+#define saturate( a ) clamp( a, 0.0, 1.0 )
+#endif
+
+uniform float toneMappingExposure;
+
+// exposure only
+vec3 LinearToneMapping( vec3 color ) {
+
+	return toneMappingExposure * color;
+
+}
+
+// source: https://www.cs.utah.edu/docs/techreports/2002/pdf/UUCS-02-001.pdf
+vec3 ReinhardToneMapping( vec3 color ) {
+
+	color *= toneMappingExposure;
+	return saturate( color / ( vec3( 1.0 ) + color ) );
+
+}
+
+// source: http://filmicworlds.com/blog/filmic-tonemapping-operators/
+vec3 OptimizedCineonToneMapping( vec3 color ) {
+
+	// optimized filmic operator by Jim Hejl and Richard Burgess-Dawson
+	color *= toneMappingExposure;
+	color = max( vec3( 0.0 ), color - 0.004 );
+	return pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );
+
+}
+
+// source: https://github.com/selfshadow/ltc_code/blob/master/webgl/shaders/ltc/ltc_blit.fs
+vec3 RRTAndODTFit( vec3 v ) {
+
+	vec3 a = v * ( v + 0.0245786 ) - 0.000090537;
+	vec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;
+	return a / b;
+
+}
+
+// this implementation of ACES is modified to accommodate a brighter viewing environment.
+// the scale factor of 1/0.6 is subjective. see discussion in #19621.
+
+vec3 ACESFilmicToneMapping( vec3 color ) {
+
+	// sRGB => XYZ => D65_2_D60 => AP1 => RRT_SAT
+	const mat3 ACESInputMat = mat3(
+		vec3( 0.59719, 0.07600, 0.02840 ), // transposed from source
+		vec3( 0.35458, 0.90834, 0.13383 ),
+		vec3( 0.04823, 0.01566, 0.83777 )
+	);
+
+	// ODT_SAT => XYZ => D60_2_D65 => sRGB
+	const mat3 ACESOutputMat = mat3(
+		vec3(  1.60475, -0.10208, -0.00327 ), // transposed from source
+		vec3( -0.53108,  1.10813, -0.07276 ),
+		vec3( -0.07367, -0.00605,  1.07602 )
+	);
+
+	color *= toneMappingExposure / 0.6;
+
+	color = ACESInputMat * color;
+
+	// Apply RRT and ODT
+	color = RRTAndODTFit( color );
+
+	color = ACESOutputMat * color;
+
+	// Clamp to [0, 1]
+	return saturate( color );
+
+}
+
+vec3 CustomToneMapping( vec3 color ) { return color; }
+`;

package/src/renderers/shaders/ShaderChunk/transmission_fragment.glsl.js

@@ -0,0 +1,36 @@
+export default /* glsl */`
+#ifdef USE_TRANSMISSION
+
+	material.transmission = transmission;
+	material.transmissionAlpha = 1.0;
+	material.thickness = thickness;
+	material.attenuationDistance = attenuationDistance;
+	material.attenuationColor = attenuationColor;
+
+	#ifdef USE_TRANSMISSIONMAP
+
+		material.transmission *= texture2D( transmissionMap, vUv ).r;
+
+	#endif
+
+	#ifdef USE_THICKNESSMAP
+
+		material.thickness *= texture2D( thicknessMap, vUv ).g;
+
+	#endif
+
+	vec3 pos = vWorldPosition;
+	vec3 v = normalize( cameraPosition - pos );
+	vec3 n = inverseTransformDirection( normal, viewMatrix );
+
+	vec4 transmission = getIBLVolumeRefraction(
+		n, v, material.roughness, material.diffuseColor, material.specularColor, material.specularF90,
+		pos, modelMatrix, viewMatrix, projectionMatrix, material.ior, material.thickness,
+		material.attenuationColor, material.attenuationDistance );
+
+	material.transmissionAlpha = mix( material.transmissionAlpha, transmission.a, material.transmission );
+
+	totalDiffuse = mix( totalDiffuse, transmission.rgb, material.transmission );
+
+#endif
+`;

package/src/renderers/shaders/ShaderChunk/transmission_pars_fragment.glsl.js

@@ -0,0 +1,116 @@
+export default /* glsl */`
+#ifdef USE_TRANSMISSION
+
+	// Transmission code is based on glTF-Sampler-Viewer
+	// https://github.com/KhronosGroup/glTF-Sample-Viewer
+
+	uniform float transmission;
+	uniform float thickness;
+	uniform float attenuationDistance;
+	uniform vec3 attenuationColor;
+
+	#ifdef USE_TRANSMISSIONMAP
+
+		uniform sampler2D transmissionMap;
+
+	#endif
+
+	#ifdef USE_THICKNESSMAP
+
+		uniform sampler2D thicknessMap;
+
+	#endif
+
+	uniform vec2 transmissionSamplerSize;
+	uniform sampler2D transmissionSamplerMap;
+
+	uniform mat4 modelMatrix;
+	uniform mat4 projectionMatrix;
+
+	varying vec3 vWorldPosition;
+
+	vec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {
+
+		// Direction of refracted light.
+		vec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );
+
+		// Compute rotation-independant scaling of the model matrix.
+		vec3 modelScale;
+		modelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );
+		modelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );
+		modelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );
+
+		// The thickness is specified in local space.
+		return normalize( refractionVector ) * thickness * modelScale;
+
+	}
+
+	float applyIorToRoughness( const in float roughness, const in float ior ) {
+
+		// Scale roughness with IOR so that an IOR of 1.0 results in no microfacet refraction and
+		// an IOR of 1.5 results in the default amount of microfacet refraction.
+		return roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );
+
+	}
+
+	vec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {
+
+		float framebufferLod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );
+
+		#ifdef texture2DLodEXT
+
+			return texture2DLodEXT( transmissionSamplerMap, fragCoord.xy, framebufferLod );
+
+		#else
+
+			return texture2D( transmissionSamplerMap, fragCoord.xy, framebufferLod );
+
+		#endif
+
+	}
+
+	vec3 applyVolumeAttenuation( const in vec3 radiance, const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {
+
+		if ( isinf( attenuationDistance ) ) {
+
+			// Attenuation distance is +∞, i.e. the transmitted color is not attenuated at all.
+			return radiance;
+
+		} else {
+
+			// Compute light attenuation using Beer's law.
+			vec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;
+			vec3 transmittance = exp( - attenuationCoefficient * transmissionDistance ); // Beer's law
+			return transmittance * radiance;
+
+		}
+
+	}
+
+	vec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,
+		const in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,
+		const in mat4 viewMatrix, const in mat4 projMatrix, const in float ior, const in float thickness,
+		const in vec3 attenuationColor, const in float attenuationDistance ) {
+
+		vec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );
+		vec3 refractedRayExit = position + transmissionRay;
+
+		// Project refracted vector on the framebuffer, while mapping to normalized device coordinates.
+		vec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );
+		vec2 refractionCoords = ndcPos.xy / ndcPos.w;
+		refractionCoords += 1.0;
+		refractionCoords /= 2.0;
+
+		// Sample framebuffer to get pixel the refracted ray hits.
+		vec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );
+
+		vec3 attenuatedColor = applyVolumeAttenuation( transmittedLight.rgb, length( transmissionRay ), attenuationColor, attenuationDistance );
+
+		// Get the specular component.
+		vec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );
+
+		return vec4( ( 1.0 - F ) * attenuatedColor * diffuseColor, transmittedLight.a );
+
+	}
+#endif
+`;

package/src/renderers/shaders/ShaderChunk/uv2_pars_fragment.glsl.js

@@ -0,0 +1,7 @@
+export default /* glsl */`
+#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
+
+	varying vec2 vUv2;
+
+#endif
+`;

package/src/renderers/shaders/ShaderChunk/uv2_pars_vertex.glsl.js

@@ -0,0 +1,10 @@
+export default /* glsl */`
+#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
+
+	attribute vec2 uv2;
+	varying vec2 vUv2;
+
+	uniform mat3 uv2Transform;
+
+#endif
+`;

package/src/renderers/shaders/ShaderChunk/uv2_vertex.glsl.js

@@ -0,0 +1,7 @@
+export default /* glsl */`
+#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
+
+	vUv2 = ( uv2Transform * vec3( uv2, 1 ) ).xy;
+
+#endif
+`;

package/src/renderers/shaders/ShaderChunk/uv_pars_fragment.glsl.js

@@ -0,0 +1,7 @@
+export default /* glsl */`
+#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )
+
+	varying vec2 vUv;
+
+#endif
+`;

package/src/renderers/shaders/ShaderChunk/uv_pars_vertex.glsl.js

@@ -0,0 +1,17 @@
+export default /* glsl */`
+#ifdef USE_UV
+
+	#ifdef UVS_VERTEX_ONLY
+
+		vec2 vUv;
+
+	#else
+
+		varying vec2 vUv;
+
+	#endif
+
+	uniform mat3 uvTransform;
+
+#endif
+`;

package/src/renderers/shaders/ShaderChunk/uv_vertex.glsl.js

@@ -0,0 +1,7 @@
+export default /* glsl */`
+#ifdef USE_UV
+
+	vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
+
+#endif
+`;

package/src/renderers/shaders/ShaderChunk/worldpos_vertex.glsl.js

@@ -0,0 +1,15 @@
+export default /* glsl */`
+#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION ) || NUM_SPOT_LIGHT_COORDS > 0
+
+	vec4 worldPosition = vec4( transformed, 1.0 );
+
+	#ifdef USE_INSTANCING
+
+		worldPosition = instanceMatrix * worldPosition;
+
+	#endif
+
+	worldPosition = modelMatrix * worldPosition;
+
+#endif
+`;

package/src/renderers/shaders/ShaderChunk.js

@@ -0,0 +1,265 @@
+import alphamap_fragment from './ShaderChunk/alphamap_fragment.glsl.js';
+import alphamap_pars_fragment from './ShaderChunk/alphamap_pars_fragment.glsl.js';
+import alphatest_fragment from './ShaderChunk/alphatest_fragment.glsl.js';
+import alphatest_pars_fragment from './ShaderChunk/alphatest_pars_fragment.glsl.js';
+import aomap_fragment from './ShaderChunk/aomap_fragment.glsl.js';
+import aomap_pars_fragment from './ShaderChunk/aomap_pars_fragment.glsl.js';
+import begin_vertex from './ShaderChunk/begin_vertex.glsl.js';
+import beginnormal_vertex from './ShaderChunk/beginnormal_vertex.glsl.js';
+import bsdfs from './ShaderChunk/bsdfs.glsl.js';
+import iridescence_fragment from './ShaderChunk/iridescence_fragment.glsl.js';
+import bumpmap_pars_fragment from './ShaderChunk/bumpmap_pars_fragment.glsl.js';
+import clipping_planes_fragment from './ShaderChunk/clipping_planes_fragment.glsl.js';
+import clipping_planes_pars_fragment from './ShaderChunk/clipping_planes_pars_fragment.glsl.js';
+import clipping_planes_pars_vertex from './ShaderChunk/clipping_planes_pars_vertex.glsl.js';
+import clipping_planes_vertex from './ShaderChunk/clipping_planes_vertex.glsl.js';
+import color_fragment from './ShaderChunk/color_fragment.glsl.js';
+import color_pars_fragment from './ShaderChunk/color_pars_fragment.glsl.js';
+import color_pars_vertex from './ShaderChunk/color_pars_vertex.glsl.js';
+import color_vertex from './ShaderChunk/color_vertex.glsl.js';
+import common from './ShaderChunk/common.glsl.js';
+import cube_uv_reflection_fragment from './ShaderChunk/cube_uv_reflection_fragment.glsl.js';
+import defaultnormal_vertex from './ShaderChunk/defaultnormal_vertex.glsl.js';
+import displacementmap_pars_vertex from './ShaderChunk/displacementmap_pars_vertex.glsl.js';
+import displacementmap_vertex from './ShaderChunk/displacementmap_vertex.glsl.js';
+import emissivemap_fragment from './ShaderChunk/emissivemap_fragment.glsl.js';
+import emissivemap_pars_fragment from './ShaderChunk/emissivemap_pars_fragment.glsl.js';
+import encodings_fragment from './ShaderChunk/encodings_fragment.glsl.js';
+import encodings_pars_fragment from './ShaderChunk/encodings_pars_fragment.glsl.js';
+import envmap_fragment from './ShaderChunk/envmap_fragment.glsl.js';
+import envmap_common_pars_fragment from './ShaderChunk/envmap_common_pars_fragment.glsl.js';
+import envmap_pars_fragment from './ShaderChunk/envmap_pars_fragment.glsl.js';
+import envmap_pars_vertex from './ShaderChunk/envmap_pars_vertex.glsl.js';
+import envmap_vertex from './ShaderChunk/envmap_vertex.glsl.js';
+import fog_vertex from './ShaderChunk/fog_vertex.glsl.js';
+import fog_pars_vertex from './ShaderChunk/fog_pars_vertex.glsl.js';
+import fog_fragment from './ShaderChunk/fog_fragment.glsl.js';
+import fog_pars_fragment from './ShaderChunk/fog_pars_fragment.glsl.js';
+import gradientmap_pars_fragment from './ShaderChunk/gradientmap_pars_fragment.glsl.js';
+import lightmap_fragment from './ShaderChunk/lightmap_fragment.glsl.js';
+import lightmap_pars_fragment from './ShaderChunk/lightmap_pars_fragment.glsl.js';
+import lights_lambert_fragment from './ShaderChunk/lights_lambert_fragment.glsl.js';
+import lights_lambert_pars_fragment from './ShaderChunk/lights_lambert_pars_fragment.glsl.js';
+import lights_pars_begin from './ShaderChunk/lights_pars_begin.glsl.js';
+import envmap_physical_pars_fragment from './ShaderChunk/envmap_physical_pars_fragment.glsl.js';
+import lights_toon_fragment from './ShaderChunk/lights_toon_fragment.glsl.js';
+import lights_toon_pars_fragment from './ShaderChunk/lights_toon_pars_fragment.glsl.js';
+import lights_phong_fragment from './ShaderChunk/lights_phong_fragment.glsl.js';
+import lights_phong_pars_fragment from './ShaderChunk/lights_phong_pars_fragment.glsl.js';
+import lights_physical_fragment from './ShaderChunk/lights_physical_fragment.glsl.js';
+import lights_physical_pars_fragment from './ShaderChunk/lights_physical_pars_fragment.glsl.js';
+import lights_fragment_begin from './ShaderChunk/lights_fragment_begin.glsl.js';
+import lights_fragment_maps from './ShaderChunk/lights_fragment_maps.glsl.js';
+import lights_fragment_end from './ShaderChunk/lights_fragment_end.glsl.js';
+import logdepthbuf_fragment from './ShaderChunk/logdepthbuf_fragment.glsl.js';
+import logdepthbuf_pars_fragment from './ShaderChunk/logdepthbuf_pars_fragment.glsl.js';
+import logdepthbuf_pars_vertex from './ShaderChunk/logdepthbuf_pars_vertex.glsl.js';
+import logdepthbuf_vertex from './ShaderChunk/logdepthbuf_vertex.glsl.js';
+import map_fragment from './ShaderChunk/map_fragment.glsl.js';
+import map_pars_fragment from './ShaderChunk/map_pars_fragment.glsl.js';
+import map_particle_fragment from './ShaderChunk/map_particle_fragment.glsl.js';
+import map_particle_pars_fragment from './ShaderChunk/map_particle_pars_fragment.glsl.js';
+import metalnessmap_fragment from './ShaderChunk/metalnessmap_fragment.glsl.js';
+import metalnessmap_pars_fragment from './ShaderChunk/metalnessmap_pars_fragment.glsl.js';
+import morphcolor_vertex from './ShaderChunk/morphcolor_vertex.glsl.js';
+import morphnormal_vertex from './ShaderChunk/morphnormal_vertex.glsl.js';
+import morphtarget_pars_vertex from './ShaderChunk/morphtarget_pars_vertex.glsl.js';
+import morphtarget_vertex from './ShaderChunk/morphtarget_vertex.glsl.js';
+import normal_fragment_begin from './ShaderChunk/normal_fragment_begin.glsl.js';
+import normal_fragment_maps from './ShaderChunk/normal_fragment_maps.glsl.js';
+import normal_pars_fragment from './ShaderChunk/normal_pars_fragment.glsl.js';
+import normal_pars_vertex from './ShaderChunk/normal_pars_vertex.glsl.js';
+import normal_vertex from './ShaderChunk/normal_vertex.glsl.js';
+import normalmap_pars_fragment from './ShaderChunk/normalmap_pars_fragment.glsl.js';
+import clearcoat_normal_fragment_begin from './ShaderChunk/clearcoat_normal_fragment_begin.glsl.js';
+import clearcoat_normal_fragment_maps from './ShaderChunk/clearcoat_normal_fragment_maps.glsl.js';
+import clearcoat_pars_fragment from './ShaderChunk/clearcoat_pars_fragment.glsl.js';
+import iridescence_pars_fragment from './ShaderChunk/iridescence_pars_fragment.glsl.js';
+import output_fragment from './ShaderChunk/output_fragment.glsl.js';
+import packing from './ShaderChunk/packing.glsl.js';
+import premultiplied_alpha_fragment from './ShaderChunk/premultiplied_alpha_fragment.glsl.js';
+import project_vertex from './ShaderChunk/project_vertex.glsl.js';
+import dithering_fragment from './ShaderChunk/dithering_fragment.glsl.js';
+import dithering_pars_fragment from './ShaderChunk/dithering_pars_fragment.glsl.js';
+import roughnessmap_fragment from './ShaderChunk/roughnessmap_fragment.glsl.js';
+import roughnessmap_pars_fragment from './ShaderChunk/roughnessmap_pars_fragment.glsl.js';
+import shadowmap_pars_fragment from './ShaderChunk/shadowmap_pars_fragment.glsl.js';
+import shadowmap_pars_vertex from './ShaderChunk/shadowmap_pars_vertex.glsl.js';
+import shadowmap_vertex from './ShaderChunk/shadowmap_vertex.glsl.js';
+import shadowmask_pars_fragment from './ShaderChunk/shadowmask_pars_fragment.glsl.js';
+import skinbase_vertex from './ShaderChunk/skinbase_vertex.glsl.js';
+import skinning_pars_vertex from './ShaderChunk/skinning_pars_vertex.glsl.js';
+import skinning_vertex from './ShaderChunk/skinning_vertex.glsl.js';
+import skinnormal_vertex from './ShaderChunk/skinnormal_vertex.glsl.js';
+import specularmap_fragment from './ShaderChunk/specularmap_fragment.glsl.js';
+import specularmap_pars_fragment from './ShaderChunk/specularmap_pars_fragment.glsl.js';
+import tonemapping_fragment from './ShaderChunk/tonemapping_fragment.glsl.js';
+import tonemapping_pars_fragment from './ShaderChunk/tonemapping_pars_fragment.glsl.js';
+import transmission_fragment from './ShaderChunk/transmission_fragment.glsl.js';
+import transmission_pars_fragment from './ShaderChunk/transmission_pars_fragment.glsl.js';
+import uv_pars_fragment from './ShaderChunk/uv_pars_fragment.glsl.js';
+import uv_pars_vertex from './ShaderChunk/uv_pars_vertex.glsl.js';
+import uv_vertex from './ShaderChunk/uv_vertex.glsl.js';
+import uv2_pars_fragment from './ShaderChunk/uv2_pars_fragment.glsl.js';
+import uv2_pars_vertex from './ShaderChunk/uv2_pars_vertex.glsl.js';
+import uv2_vertex from './ShaderChunk/uv2_vertex.glsl.js';
+import worldpos_vertex from './ShaderChunk/worldpos_vertex.glsl.js';
+
+import * as background from './ShaderLib/background.glsl.js';
+import * as cube from './ShaderLib/cube.glsl.js';
+import * as depth from './ShaderLib/depth.glsl.js';
+import * as distanceRGBA from './ShaderLib/distanceRGBA.glsl.js';
+import * as equirect from './ShaderLib/equirect.glsl.js';
+import * as linedashed from './ShaderLib/linedashed.glsl.js';
+import * as meshbasic from './ShaderLib/meshbasic.glsl.js';
+import * as meshlambert from './ShaderLib/meshlambert.glsl.js';
+import * as meshmatcap from './ShaderLib/meshmatcap.glsl.js';
+import * as meshnormal from './ShaderLib/meshnormal.glsl.js';
+import * as meshphong from './ShaderLib/meshphong.glsl.js';
+import * as meshphysical from './ShaderLib/meshphysical.glsl.js';
+import * as meshtoon from './ShaderLib/meshtoon.glsl.js';
+import * as points from './ShaderLib/points.glsl.js';
+import * as shadow from './ShaderLib/shadow.glsl.js';
+import * as sprite from './ShaderLib/sprite.glsl.js';
+
+export const ShaderChunk = {
+	alphamap_fragment: alphamap_fragment,
+	alphamap_pars_fragment: alphamap_pars_fragment,
+	alphatest_fragment: alphatest_fragment,
+	alphatest_pars_fragment: alphatest_pars_fragment,
+	aomap_fragment: aomap_fragment,
+	aomap_pars_fragment: aomap_pars_fragment,
+	begin_vertex: begin_vertex,
+	beginnormal_vertex: beginnormal_vertex,
+	bsdfs: bsdfs,
+	iridescence_fragment: iridescence_fragment,
+	bumpmap_pars_fragment: bumpmap_pars_fragment,
+	clipping_planes_fragment: clipping_planes_fragment,
+	clipping_planes_pars_fragment: clipping_planes_pars_fragment,
+	clipping_planes_pars_vertex: clipping_planes_pars_vertex,
+	clipping_planes_vertex: clipping_planes_vertex,
+	color_fragment: color_fragment,
+	color_pars_fragment: color_pars_fragment,
+	color_pars_vertex: color_pars_vertex,
+	color_vertex: color_vertex,
+	common: common,
+	cube_uv_reflection_fragment: cube_uv_reflection_fragment,
+	defaultnormal_vertex: defaultnormal_vertex,
+	displacementmap_pars_vertex: displacementmap_pars_vertex,
+	displacementmap_vertex: displacementmap_vertex,
+	emissivemap_fragment: emissivemap_fragment,
+	emissivemap_pars_fragment: emissivemap_pars_fragment,
+	encodings_fragment: encodings_fragment,
+	encodings_pars_fragment: encodings_pars_fragment,
+	envmap_fragment: envmap_fragment,
+	envmap_common_pars_fragment: envmap_common_pars_fragment,
+	envmap_pars_fragment: envmap_pars_fragment,
+	envmap_pars_vertex: envmap_pars_vertex,
+	envmap_physical_pars_fragment: envmap_physical_pars_fragment,
+	envmap_vertex: envmap_vertex,
+	fog_vertex: fog_vertex,
+	fog_pars_vertex: fog_pars_vertex,
+	fog_fragment: fog_fragment,
+	fog_pars_fragment: fog_pars_fragment,
+	gradientmap_pars_fragment: gradientmap_pars_fragment,
+	lightmap_fragment: lightmap_fragment,
+	lightmap_pars_fragment: lightmap_pars_fragment,
+	lights_lambert_fragment: lights_lambert_fragment,
+	lights_lambert_pars_fragment: lights_lambert_pars_fragment,
+	lights_pars_begin: lights_pars_begin,
+	lights_toon_fragment: lights_toon_fragment,
+	lights_toon_pars_fragment: lights_toon_pars_fragment,
+	lights_phong_fragment: lights_phong_fragment,
+	lights_phong_pars_fragment: lights_phong_pars_fragment,
+	lights_physical_fragment: lights_physical_fragment,
+	lights_physical_pars_fragment: lights_physical_pars_fragment,
+	lights_fragment_begin: lights_fragment_begin,
+	lights_fragment_maps: lights_fragment_maps,
+	lights_fragment_end: lights_fragment_end,
+	logdepthbuf_fragment: logdepthbuf_fragment,
+	logdepthbuf_pars_fragment: logdepthbuf_pars_fragment,
+	logdepthbuf_pars_vertex: logdepthbuf_pars_vertex,
+	logdepthbuf_vertex: logdepthbuf_vertex,
+	map_fragment: map_fragment,
+	map_pars_fragment: map_pars_fragment,
+	map_particle_fragment: map_particle_fragment,
+	map_particle_pars_fragment: map_particle_pars_fragment,
+	metalnessmap_fragment: metalnessmap_fragment,
+	metalnessmap_pars_fragment: metalnessmap_pars_fragment,
+	morphcolor_vertex: morphcolor_vertex,
+	morphnormal_vertex: morphnormal_vertex,
+	morphtarget_pars_vertex: morphtarget_pars_vertex,
+	morphtarget_vertex: morphtarget_vertex,
+	normal_fragment_begin: normal_fragment_begin,
+	normal_fragment_maps: normal_fragment_maps,
+	normal_pars_fragment: normal_pars_fragment,
+	normal_pars_vertex: normal_pars_vertex,
+	normal_vertex: normal_vertex,
+	normalmap_pars_fragment: normalmap_pars_fragment,
+	clearcoat_normal_fragment_begin: clearcoat_normal_fragment_begin,
+	clearcoat_normal_fragment_maps: clearcoat_normal_fragment_maps,
+	clearcoat_pars_fragment: clearcoat_pars_fragment,
+	iridescence_pars_fragment: iridescence_pars_fragment,
+	output_fragment: output_fragment,
+	packing: packing,
+	premultiplied_alpha_fragment: premultiplied_alpha_fragment,
+	project_vertex: project_vertex,
+	dithering_fragment: dithering_fragment,
+	dithering_pars_fragment: dithering_pars_fragment,
+	roughnessmap_fragment: roughnessmap_fragment,
+	roughnessmap_pars_fragment: roughnessmap_pars_fragment,
+	shadowmap_pars_fragment: shadowmap_pars_fragment,
+	shadowmap_pars_vertex: shadowmap_pars_vertex,
+	shadowmap_vertex: shadowmap_vertex,
+	shadowmask_pars_fragment: shadowmask_pars_fragment,
+	skinbase_vertex: skinbase_vertex,
+	skinning_pars_vertex: skinning_pars_vertex,
+	skinning_vertex: skinning_vertex,
+	skinnormal_vertex: skinnormal_vertex,
+	specularmap_fragment: specularmap_fragment,
+	specularmap_pars_fragment: specularmap_pars_fragment,
+	tonemapping_fragment: tonemapping_fragment,
+	tonemapping_pars_fragment: tonemapping_pars_fragment,
+	transmission_fragment: transmission_fragment,
+	transmission_pars_fragment: transmission_pars_fragment,
+	uv_pars_fragment: uv_pars_fragment,
+	uv_pars_vertex: uv_pars_vertex,
+	uv_vertex: uv_vertex,
+	uv2_pars_fragment: uv2_pars_fragment,
+	uv2_pars_vertex: uv2_pars_vertex,
+	uv2_vertex: uv2_vertex,
+	worldpos_vertex: worldpos_vertex,
+
+	background_vert: background.vertex,
+	background_frag: background.fragment,
+	cube_vert: cube.vertex,
+	cube_frag: cube.fragment,
+	depth_vert: depth.vertex,
+	depth_frag: depth.fragment,
+	distanceRGBA_vert: distanceRGBA.vertex,
+	distanceRGBA_frag: distanceRGBA.fragment,
+	equirect_vert: equirect.vertex,
+	equirect_frag: equirect.fragment,
+	linedashed_vert: linedashed.vertex,
+	linedashed_frag: linedashed.fragment,
+	meshbasic_vert: meshbasic.vertex,
+	meshbasic_frag: meshbasic.fragment,
+	meshlambert_vert: meshlambert.vertex,
+	meshlambert_frag: meshlambert.fragment,
+	meshmatcap_vert: meshmatcap.vertex,
+	meshmatcap_frag: meshmatcap.fragment,
+	meshnormal_vert: meshnormal.vertex,
+	meshnormal_frag: meshnormal.fragment,
+	meshphong_vert: meshphong.vertex,
+	meshphong_frag: meshphong.fragment,
+	meshphysical_vert: meshphysical.vertex,
+	meshphysical_frag: meshphysical.fragment,
+	meshtoon_vert: meshtoon.vertex,
+	meshtoon_frag: meshtoon.fragment,
+	points_vert: points.vertex,
+	points_frag: points.fragment,
+	shadow_vert: shadow.vertex,
+	shadow_frag: shadow.fragment,
+	sprite_vert: sprite.vertex,
+	sprite_frag: sprite.fragment
+};

package/src/renderers/shaders/ShaderLib/background.glsl.js

@@ -0,0 +1,35 @@
+export const vertex = /* glsl */`
+varying vec2 vUv;
+uniform mat3 uvTransform;
+
+void main() {
+
+	vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
+
+	gl_Position = vec4( position.xy, 1.0, 1.0 );
+
+}
+`;
+
+export const fragment = /* glsl */`
+uniform sampler2D t2D;
+
+varying vec2 vUv;
+
+void main() {
+
+	gl_FragColor = texture2D( t2D, vUv );
+
+	#ifdef DECODE_VIDEO_TEXTURE
+
+		// inline sRGB decode (TODO: Remove this code when https://crbug.com/1256340 is solved)
+
+		gl_FragColor = vec4( mix( pow( gl_FragColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), gl_FragColor.rgb * 0.0773993808, vec3( lessThanEqual( gl_FragColor.rgb, vec3( 0.04045 ) ) ) ), gl_FragColor.w );
+
+	#endif
+
+	#include <tonemapping_fragment>
+	#include <encodings_fragment>
+
+}
+`;

package/src/renderers/shaders/ShaderLib/cube.glsl.js

@@ -0,0 +1,38 @@
+export const vertex = /* glsl */`
+varying vec3 vWorldDirection;
+
+#include <common>
+
+void main() {
+
+	vWorldDirection = transformDirection( position, modelMatrix );
+
+	#include <begin_vertex>
+	#include <project_vertex>
+
+	gl_Position.z = gl_Position.w; // set z to camera.far
+
+}
+`;
+
+export const fragment = /* glsl */`
+#include <envmap_common_pars_fragment>
+uniform float opacity;
+
+varying vec3 vWorldDirection;
+
+#include <cube_uv_reflection_fragment>
+
+void main() {
+
+	vec3 vReflect = vWorldDirection;
+	#include <envmap_fragment>
+
+	gl_FragColor = envColor;
+	gl_FragColor.a *= opacity;
+
+	#include <tonemapping_fragment>
+	#include <encodings_fragment>
+
+}
+`;