Merge pull request #19157 from marcofugaro/translucecncy-to-subsurface

Translucency --> Subsurface Scattering

examples/files.js

@@ -159,13 +159,13 @@ var files = {
 		"webgl_materials_physical_transparency",
 		"webgl_materials_shaders_fresnel",
 		"webgl_materials_standard",
+		"webgl_materials_subsurface_scattering",
 		"webgl_materials_texture_anisotropy",
 		"webgl_materials_texture_canvas",
 		"webgl_materials_texture_filters",
 		"webgl_materials_texture_manualmipmap",
 		"webgl_materials_texture_partialupdate",
 		"webgl_materials_texture_rotation",
-		"webgl_materials_translucency",
 		"webgl_materials_variations_basic",
 		"webgl_materials_variations_lambert",
 		"webgl_materials_variations_phong",

examples/js/shaders/SubsurfaceScatteringShader.js

@@ -0,0 +1,81 @@
+/**
+ * @author daoshengmu / http://dsmu.me/
+ *
+ * ------------------------------------------------------------------------------------------
+ * 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/
+ *------------------------------------------------------------------------------------------
+ */
+
+function replaceAll( string, find, replace ) {
+
+	return string.split( find ).join( replace );
+
+}
+
+var meshphong_frag_head = THREE.ShaderChunk[ "meshphong_frag" ].slice( 0, THREE.ShaderChunk[ "meshphong_frag" ].indexOf( 'void main() {' ) );
+var meshphong_frag_body = THREE.ShaderChunk[ "meshphong_frag" ].slice( THREE.ShaderChunk[ "meshphong_frag" ].indexOf( 'void main() {' ) );
+
+THREE.SubsurfaceScatteringShader = {
+
+	uniforms: THREE.UniformsUtils.merge( [
+		THREE.ShaderLib[ "phong" ].uniforms,
+		{
+			"thicknessMap": { value: null },
+			"thicknessColor": { value: new THREE.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",
+		THREE.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 GeometricContext geometry, inout ReflectedLight reflectedLight) {",
+		"	vec3 thickness = thicknessColor * texture2D(thicknessMap, uv).r;",
+		"	vec3 scatteringHalf = normalize(directLight.direction + (geometry.normal * thicknessDistortion));",
+		"	float scatteringDot = pow(saturate(dot(geometry.viewDir, -scatteringHalf)), thicknessPower) * thicknessScale;",
+		"	vec3 scatteringIllu = (scatteringDot + thicknessAmbient) * thickness;",
+		"	reflectedLight.directDiffuse += scatteringIllu * thicknessAttenuation * directLight.color;",
+		"}",
+
+		meshphong_frag_body.replace( "#include <lights_fragment_begin>",
+
+			replaceAll(
+				THREE.ShaderChunk[ 'lights_fragment_begin' ],
+				'RE_Direct( directLight, geometry, material, reflectedLight );',
+				[
+					"RE_Direct( directLight, geometry, material, reflectedLight );",
+
+					"#if defined( SUBSURFACE ) && defined( USE_UV )",
+					" RE_Direct_Scattering(directLight, vUv, geometry, reflectedLight);",
+					"#endif",
+				].join( "\n" )
+			),
+
+		),
+
+	].join( "\n" ),
+
+};

examples/js/shaders/TranslucentShader.js

@@ -1,207 +0,0 @@
-/**
- * @author daoshengmu / http://dsmu.me/
- *
- * ------------------------------------------------------------------------------------------
- * Subsurface Scattering shader
- * Base 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/
- *------------------------------------------------------------------------------------------
- */
-
-THREE.TranslucentShader = {
-
-	uniforms: THREE.UniformsUtils.merge( [
-
-		THREE.UniformsLib[ "common" ],
-		THREE.UniformsLib[ "lights" ],
-		{
-			"color": { value: new THREE.Color( 0xffffff ) },
-			"diffuse": { value: new THREE.Color( 0xffffff ) },
-			"specular": { value: new THREE.Color( 0xffffff ) },
-			"emissive": { value: new THREE.Color( 0x000000 ) },
-			"opacity": { value: 1 },
-			"shininess": { value: 1 },
-
-			"thicknessMap": { value: null },
-			"thicknessColor": { value: new THREE.Color( 0xffffff ) },
-			"thicknessDistortion": { value: 0.1 },
-			"thicknessAmbient": { value: 0.0 },
-			"thicknessAttenuation": { value: 0.1 },
-			"thicknessPower": { value: 2.0 },
-			"thicknessScale": { value: 10.0 }
-		}
-
-	] ),
-
-	vertexShader: [
-
-		"varying vec3 vNormal;",
-		"varying vec2 vUv;",
-
-		"varying vec3 vViewPosition;",
-
-		THREE.ShaderChunk[ "common" ],
-
-		"void main() {",
-
-		"	vec4 worldPosition = modelMatrix * vec4( position, 1.0 );",
-
-		"	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
-
-		"	vViewPosition = -mvPosition.xyz;",
-
-		"	vNormal = normalize( normalMatrix * normal );",
-
-		"	vUv = uv;",
-
-		"	gl_Position = projectionMatrix * mvPosition;",
-
-		"}",
-
-	].join( "\n" ),
-
-	fragmentShader: [
-		"#define USE_UV",
-		"#define USE_MAP",
-		"#define PHONG",
-		"#define TRANSLUCENT",
-		"#include <common>",
-		"#include <bsdfs>",
-		"#include <uv_pars_fragment>",
-		"#include <map_pars_fragment>",
-		"#include <lights_phong_pars_fragment>",
-
-		"varying vec3 vColor;",
-
-		"uniform vec3 diffuse;",
-		"uniform vec3 specular;",
-		"uniform vec3 emissive;",
-		"uniform float opacity;",
-		"uniform float shininess;",
-
-		// Translucency
-		"uniform sampler2D thicknessMap;",
-		"uniform float thicknessPower;",
-		"uniform float thicknessScale;",
-		"uniform float thicknessDistortion;",
-		"uniform float thicknessAmbient;",
-		"uniform float thicknessAttenuation;",
-		"uniform vec3 thicknessColor;",
-
-		THREE.ShaderChunk[ "lights_pars_begin" ],
-
-		"void RE_Direct_Scattering(const in IncidentLight directLight, const in vec2 uv, const in GeometricContext geometry, inout ReflectedLight reflectedLight) {",
-		"	vec3 thickness = thicknessColor * texture2D(thicknessMap, uv).r;",
-		"	vec3 scatteringHalf = normalize(directLight.direction + (geometry.normal * thicknessDistortion));",
-		"	float scatteringDot = pow(saturate(dot(geometry.viewDir, -scatteringHalf)), thicknessPower) * thicknessScale;",
-		"	vec3 scatteringIllu = (scatteringDot + thicknessAmbient) * thickness;",
-		"	reflectedLight.directDiffuse += scatteringIllu * thicknessAttenuation * directLight.color;",
-		"}",
-
-		"void main() {",
-
-		"	vec3 normal = normalize( vNormal );",
-
-		"	vec3 viewerDirection = normalize( vViewPosition );",
-
-		"	vec4 diffuseColor = vec4( diffuse, opacity );",
-		"	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );",
-
-		THREE.ShaderChunk[ "map_fragment" ],
-		THREE.ShaderChunk[ "color_fragment" ],
-		THREE.ShaderChunk[ "specularmap_fragment" ],
-
-		"	vec3 totalEmissiveRadiance = emissive;",
-
-		THREE.ShaderChunk[ "lights_phong_fragment" ],
-
-		// Doing lights fragment begin.
-		"	GeometricContext geometry;",
-		"	geometry.position = - vViewPosition;",
-		"	geometry.normal = normal;",
-		"	geometry.viewDir = normalize( vViewPosition );",
-
-		"	IncidentLight directLight;",
-
-		"	#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )",
-
-		"		PointLight pointLight;",
-
-		"		#pragma unroll_loop_start",
-		"		for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {",
-		"		 	pointLight = pointLights[ i ];",
-		"		 	getPointDirectLightIrradiance( pointLight, geometry, directLight );",
-
-		"			#ifdef USE_SHADOWMAP",
-		"			directLight.color *= all( bvec2( pointLight.shadow, directLight.visible ) ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;",
-		"			#endif",
-
-		"			RE_Direct( directLight, geometry, material, reflectedLight );",
-
-		"			#if defined( TRANSLUCENT ) && defined( USE_UV )",
-		"			RE_Direct_Scattering(directLight, vUv, geometry, reflectedLight);",
-		"			#endif",
-		"		}",
-		"		#pragma unroll_loop_end",
-
-		"		#endif",
-
-		"	#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )",
-
-		"		DirectionalLight directionalLight;",
-
-		"		#pragma unroll_loop_start",
-		"		for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {",
-		"			directionalLight = directionalLights[ i ];",
-		"			getDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );",
-
-		"			#ifdef USE_SHADOWMAP",
-		"			directLight.color *= all( bvec2( directionalLight.shadow, directLight.visible ) ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;",
-		"			#endif",
-
-		"			RE_Direct( directLight, geometry, material, reflectedLight );",
-
-		"			#if defined( TRANSLUCENT ) && defined( USE_UV )",
-		"			RE_Direct_Scattering(directLight, vUv, geometry, reflectedLight);",
-		"			#endif",
-		"		}",
-		"		#pragma unroll_loop_end",
-
-		"	#endif",
-
-		"	#if defined( RE_IndirectDiffuse )",
-
-		"		vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );",
-
-		"		#if ( NUM_HEMI_LIGHTS > 0 )",
-
-		"			#pragma unroll_loop_start",
-		"			for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {",
-
-		"				irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );",
-
-		"			}",
-		"			#pragma unroll_loop_end",
-
-		"		#endif",
-
-		"	#endif",
-
-		"	#if defined( RE_IndirectSpecular )",
-
-		"		vec3 radiance = vec3( 0.0 );",
-		"		vec3 clearcoatRadiance = vec3( 0.0 );",
-
-		"	#endif",
-		THREE.ShaderChunk[ "lights_fragment_end" ],
-
-		"	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;",
-		"	gl_FragColor = vec4( outgoingLight, diffuseColor.a );",	// TODO, this should be pre-multiplied to allow for bright highlights on very transparent objects
-
-		THREE.ShaderChunk[ "encodings_fragment" ],
-
-		"}"
-
-	].join( "\n" ),
-
-};

examples/jsm/shaders/TranslucentShader.d.ts → examples/jsm/shaders/SubsurfaceScatteringShader.d.ts

@@ -2,7 +2,7 @@ import {
 	Uniform
 } from '../../../src/Three';
 
-export const TranslucentShader: {
+export const SubsurfaceScatteringShader: {
 	uniforms: {
 		alphaMap: Uniform;
 		ambientLightColor: Uniform;

examples/jsm/shaders/TranslucentShader.js → examples/jsm/shaders/SubsurfaceScatteringShader.js

@@ -24,7 +24,7 @@ function replaceAll( string, find, replace ) {
 var meshphong_frag_head = ShaderChunk[ "meshphong_frag" ].slice( 0, ShaderChunk[ "meshphong_frag" ].indexOf( 'void main() {' ) );
 var meshphong_frag_body = ShaderChunk[ "meshphong_frag" ].slice( ShaderChunk[ "meshphong_frag" ].indexOf( 'void main() {' ) );
 
-var TranslucentShader = {
+var SubsurfaceScatteringShader = {
 
 	uniforms: UniformsUtils.merge( [
 		ShaderLib[ "phong" ].uniforms,
@@ -47,7 +47,7 @@ var TranslucentShader = {
 
 	fragmentShader: [
 		"#define USE_UV",
-		"#define TRANSLUCENT",
+		"#define SUBSURFACE",
 
 		meshphong_frag_head,
 
@@ -75,7 +75,7 @@ var TranslucentShader = {
 				[
 					"RE_Direct( directLight, geometry, material, reflectedLight );",
 
-					"#if defined( TRANSLUCENT ) && defined( USE_UV )",
+					"#if defined( SUBSURFACE ) && defined( USE_UV )",
 					" RE_Direct_Scattering(directLight, vUv, geometry, reflectedLight);",
 					"#endif",
 				].join( "\n" )
@@ -87,4 +87,4 @@ var TranslucentShader = {
 
 };
 
-export { TranslucentShader };
+export { SubsurfaceScatteringShader };

examples/webgl_materials_translucency.html → examples/webgl_materials_subsurface_scattering.html

@@ -21,7 +21,7 @@
 
 		import { GUI } from './jsm/libs/dat.gui.module.js';
 		import { OrbitControls } from './jsm/controls/OrbitControls.js';
-		import { TranslucentShader } from './jsm/shaders/TranslucentShader.js';
+		import { SubsurfaceScatteringShader } from './jsm/shaders/SubsurfaceScatteringShader.js';
 		import { FBXLoader } from './jsm/loaders/FBXLoader.js';
 
 		var container, stats;
@@ -91,7 +91,7 @@
 			var thicknessTexture = loader.load( 'models/fbx/bunny_thickness.jpg' );
 			imgTexture.wrapS = imgTexture.wrapT = THREE.RepeatWrapping;
 
-			var shader = TranslucentShader;
+			var shader = SubsurfaceScatteringShader;
 			var uniforms = THREE.UniformsUtils.clone( shader.uniforms );
 
 			uniforms[ 'map' ].value = imgTexture;

utils/modularize.js

@@ -214,7 +214,7 @@ var files = [
 	{ path: 'shaders/TechnicolorShader.js', dependencies: [], ignoreList: [] },
 	{ path: 'shaders/ToneMapShader.js', dependencies: [], ignoreList: [] },
 	{ path: 'shaders/ToonShader.js', dependencies: [], ignoreList: [] },
-	{ path: 'shaders/TranslucentShader.js', dependencies: [], ignoreList: [] },
+	{ path: 'shaders/SubsurfaceScatteringShader.js', dependencies: [], ignoreList: [] },
 	{ path: 'shaders/TriangleBlurShader.js', dependencies: [], ignoreList: [] },
 	{ path: 'shaders/UnpackDepthRGBAShader.js', dependencies: [], ignoreList: [] },
 	{ path: 'shaders/VerticalBlurShader.js', dependencies: [], ignoreList: [] },