Reintroduce MeshPhysicalMaterial

* Reintroduce MeshPhysicalMaterial

* Reintroduce MeshPhysicalMaterial

* Simplified conditionals

src/materials/MeshPhysicalMaterial.js

@@ -0,0 +1,32 @@
+/**
+ * @author WestLangley / http://github.com/WestLangley
+ *
+ * parameters = {
+ *  reflectivity: <float>
+ * }
+ */
+
+THREE.MeshPhysicalMaterial = function ( parameters ) {
+
+	THREE.MeshStandardMaterial.call( this );
+
+	this.type = 'MeshPhysicalMaterial';
+
+	this.reflectivity = 0.5; // maps to F0 = 0.04
+
+	this.setValues( parameters );
+
+};
+
+THREE.MeshPhysicalMaterial.prototype = Object.create( THREE.MeshStandardMaterial.prototype );
+THREE.MeshPhysicalMaterial.prototype.constructor = THREE.MeshPhysicalMaterial;
+
+THREE.MeshPhysicalMaterial.prototype.copy = function ( source ) {
+
+	THREE.MeshStandardMaterial.prototype.copy.call( this, source );
+
+	this.reflectivity = source.reflectivity;
+
+	return this;
+
+};

src/renderers/WebGLRenderer.js

@@ -662,7 +662,7 @@ THREE.WebGLRenderer = function ( parameters ) {
 
 			_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.normal );
 
-			if ( material.type !== 'MeshPhongMaterial' && material.type !== 'MeshStandardMaterial' && material.shading === THREE.FlatShading ) {
+			if ( material.type !== 'MeshPhongMaterial' && material.type !== 'MeshStandardMaterial' && material.type !== 'MeshPhysicalMaterial' && material.shading === THREE.FlatShading ) {
 
 				for ( var i = 0, l = object.count * 3; i < l; i += 9 ) {
 
@@ -1862,6 +1862,10 @@ THREE.WebGLRenderer = function ( parameters ) {
 
 				refreshUniformsPhong( m_uniforms, material );
 
+			} else if ( material instanceof THREE.MeshPhysicalMaterial ) {
+
+				refreshUniformsPhysical( m_uniforms, material );
+
 			} else if ( material instanceof THREE.MeshStandardMaterial ) {
 
 				refreshUniformsStandard( m_uniforms, material );
@@ -2192,6 +2196,12 @@ THREE.WebGLRenderer = function ( parameters ) {
 
 	}
 
+	function refreshUniformsPhysical ( uniforms, material ) {
+
+		refreshUniformsStandard( uniforms, material );
+
+	}
+
 	// If uniforms are marked as clean, they don't need to be loaded to the GPU.
 
 	function markUniformsLightsNeedsUpdate ( uniforms, value ) {

src/renderers/shaders/ShaderChunk/lights_physical_fragment.glsl

@@ -0,0 +1,4 @@
+PhysicalMaterial material;
+material.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );
+material.specularRoughness = clamp( roughnessFactor, 0.04, 1.0 );
+material.specularColor = mix( vec3( 0.16 * pow2( reflectivity ) ), diffuseColor.rgb, metalnessFactor );

src/renderers/shaders/ShaderChunk/lights_physical_pars_fragment.glsl

@@ -0,0 +1,50 @@
+struct PhysicalMaterial {
+
+	vec3	diffuseColor;
+	float	specularRoughness;
+	vec3	specularColor;
+
+};
+
+void RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
+
+	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
+
+	vec3 irradiance = dotNL * directLight.color;
+
+	#ifndef PHYSICALLY_CORRECT_LIGHTS
+
+		irradiance *= PI; // punctual light
+
+	#endif
+
+	reflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );
+
+	reflectedLight.directSpecular += irradiance * BRDF_Specular_GGX( directLight, geometry, material.specularColor, material.specularRoughness );
+
+}
+
+void RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
+
+	reflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );
+
+}
+
+void RE_IndirectSpecular_Physical( const in vec3 radiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
+
+	reflectedLight.indirectSpecular += radiance * BRDF_Specular_GGX_Environment( geometry, material.specularColor, material.specularRoughness );
+
+}
+
+#define RE_Direct				RE_Direct_Physical
+#define RE_IndirectDiffuse		RE_IndirectDiffuse_Physical
+#define RE_IndirectSpecular		RE_IndirectSpecular_Physical
+
+#define Material_BlinnShininessExponent( material )   GGXRoughnessToBlinnExponent( material.specularRoughness )
+
+// ref: http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr_v2.pdf
+float computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {
+
+	return saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );
+
+}

src/renderers/shaders/ShaderLib.js

@@ -103,6 +103,36 @@ THREE.ShaderLib = {
 
 	},
 
+	'physical': {
+
+		uniforms: THREE.UniformsUtils.merge( [
+
+			THREE.UniformsLib[ 'common' ],
+			THREE.UniformsLib[ 'aomap' ],
+			THREE.UniformsLib[ 'lightmap' ],
+			THREE.UniformsLib[ 'emissivemap' ],
+			THREE.UniformsLib[ 'bumpmap' ],
+			THREE.UniformsLib[ 'normalmap' ],
+			THREE.UniformsLib[ 'displacementmap' ],
+			THREE.UniformsLib[ 'roughnessmap' ],
+			THREE.UniformsLib[ 'metalnessmap' ],
+			THREE.UniformsLib[ 'fog' ],
+			THREE.UniformsLib[ 'lights' ],
+
+			{
+				"emissive" : { type: "c", value: new THREE.Color( 0x000000 ) },
+				"roughness": { type: "1f", value: 0.5 },
+				"metalness": { type: "1f", value: 0 },
+				"envMapIntensity" : { type: "1f", value: 1 } // temporary
+			}
+
+		] ),
+
+		vertexShader: THREE.ShaderChunk[ 'meshphysical_vert' ],
+		fragmentShader: THREE.ShaderChunk[ 'meshphysical_frag' ]
+
+	},
+
 	'points': {
 
 		uniforms: THREE.UniformsUtils.merge( [

src/renderers/shaders/ShaderLib/meshphysical_frag.glsl

@@ -0,0 +1,75 @@
+#define STANDARD
+#define PHYSICAL
+
+uniform vec3 diffuse;
+uniform vec3 emissive;
+uniform float roughness;
+uniform float metalness;
+uniform float opacity;
+
+uniform float envMapIntensity; // temporary
+
+varying vec3 vViewPosition;
+
+#ifndef FLAT_SHADED
+
+	varying vec3 vNormal;
+
+#endif
+
+#include <common>
+#include <color_pars_fragment>
+#include <uv_pars_fragment>
+#include <uv2_pars_fragment>
+#include <map_pars_fragment>
+#include <alphamap_pars_fragment>
+#include <aomap_pars_fragment>
+#include <lightmap_pars_fragment>
+#include <emissivemap_pars_fragment>
+#include <envmap_pars_fragment>
+#include <fog_pars_fragment>
+#include <bsdfs>
+#include <cube_uv_reflection_fragment>
+#include <lights_pars>
+#include <lights_physical_pars_fragment>
+#include <shadowmap_pars_fragment>
+#include <bumpmap_pars_fragment>
+#include <normalmap_pars_fragment>
+#include <roughnessmap_pars_fragment>
+#include <metalnessmap_pars_fragment>
+#include <logdepthbuf_pars_fragment>
+
+void main() {
+
+	vec4 diffuseColor = vec4( diffuse, opacity );
+	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
+	vec3 totalEmissiveRadiance = emissive;
+
+	#include <logdepthbuf_fragment>
+	#include <map_fragment>
+	#include <color_fragment>
+	#include <alphamap_fragment>
+	#include <alphatest_fragment>
+	#include <specularmap_fragment>
+	#include <roughnessmap_fragment>
+	#include <metalnessmap_fragment>
+	#include <normal_fragment>
+	#include <emissivemap_fragment>
+
+	// accumulation
+	#include <lights_physical_fragment>
+	#include <lights_template>
+
+	// modulation
+	#include <aomap_fragment>
+
+	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;
+
+	gl_FragColor = vec4( outgoingLight, diffuseColor.a );
+
+	#include <premultiplied_alpha_fragment>
+	#include <tonemapping_fragment>
+	#include <encodings_fragment>
+	#include <fog_fragment>
+
+}

src/renderers/shaders/ShaderLib/meshphysical_vert.glsl

@@ -0,0 +1,53 @@
+#define STANDARD
+#define PHYSICAL
+
+varying vec3 vViewPosition;
+
+#ifndef FLAT_SHADED
+
+	varying vec3 vNormal;
+
+#endif
+
+#include <common>
+#include <uv_pars_vertex>
+#include <uv2_pars_vertex>
+#include <displacementmap_pars_vertex>
+#include <color_pars_vertex>
+#include <morphtarget_pars_vertex>
+#include <skinning_pars_vertex>
+#include <shadowmap_pars_vertex>
+#include <specularmap_pars_fragment>
+#include <logdepthbuf_pars_vertex>
+
+void main() {
+
+	#include <uv_vertex>
+	#include <uv2_vertex>
+	#include <color_vertex>
+
+	#include <beginnormal_vertex>
+	#include <morphnormal_vertex>
+	#include <skinbase_vertex>
+	#include <skinnormal_vertex>
+	#include <defaultnormal_vertex>
+
+#ifndef FLAT_SHADED // Normal computed with derivatives when FLAT_SHADED
+
+	vNormal = normalize( transformedNormal );
+
+#endif
+
+	#include <begin_vertex>
+	#include <displacementmap_vertex>
+	#include <morphtarget_vertex>
+	#include <skinning_vertex>
+	#include <project_vertex>
+	#include <logdepthbuf_vertex>
+
+	vViewPosition = - mvPosition.xyz;
+
+	#include <worldpos_vertex>
+	#include <shadowmap_vertex>
+
+}

src/renderers/webgl/WebGLPrograms.js

@@ -9,6 +9,7 @@ THREE.WebGLPrograms = function ( renderer, capabilities ) {
 		MeshLambertMaterial: 'lambert',
 		MeshPhongMaterial: 'phong',
 		MeshStandardMaterial: 'standard',
+		MeshPhysicalMaterial: 'physical',
 		LineBasicMaterial: 'basic',
 		LineDashedMaterial: 'dashed',
 		PointsMaterial: 'points'

utils/build/includes/common.json

@@ -91,11 +91,12 @@
 	"src/materials/LineBasicMaterial.js",
 	"src/materials/LineDashedMaterial.js",
 	"src/materials/MeshBasicMaterial.js",
+	"src/materials/MeshDepthMaterial.js",
 	"src/materials/MeshLambertMaterial.js",
+	"src/materials/MeshNormalMaterial.js",
 	"src/materials/MeshPhongMaterial.js",
 	"src/materials/MeshStandardMaterial.js",
-	"src/materials/MeshDepthMaterial.js",
-	"src/materials/MeshNormalMaterial.js",
+	"src/materials/MeshPhysicalMaterial.js",
 	"src/materials/MultiMaterial.js",
 	"src/materials/PointsMaterial.js",
 	"src/materials/ShaderMaterial.js",
@@ -156,6 +157,8 @@
 	"src/renderers/shaders/ShaderChunk/lights_pars.glsl",
 	"src/renderers/shaders/ShaderChunk/lights_phong_fragment.glsl",
 	"src/renderers/shaders/ShaderChunk/lights_phong_pars_fragment.glsl",
+	"src/renderers/shaders/ShaderChunk/lights_physical_fragment.glsl",
+	"src/renderers/shaders/ShaderChunk/lights_physical_pars_fragment.glsl",
 	"src/renderers/shaders/ShaderChunk/lights_standard_fragment.glsl",
 	"src/renderers/shaders/ShaderChunk/lights_standard_pars_fragment.glsl",
 	"src/renderers/shaders/ShaderChunk/lights_template.glsl",
@@ -217,6 +220,8 @@
 	"src/renderers/shaders/ShaderLib/meshlambert_vert.glsl",
 	"src/renderers/shaders/ShaderLib/meshphong_frag.glsl",
 	"src/renderers/shaders/ShaderLib/meshphong_vert.glsl",
+	"src/renderers/shaders/ShaderLib/meshphysical_frag.glsl",
+	"src/renderers/shaders/ShaderLib/meshphysical_vert.glsl",
 	"src/renderers/shaders/ShaderLib/meshstandard_frag.glsl",
 	"src/renderers/shaders/ShaderLib/meshstandard_vert.glsl",
 	"src/renderers/shaders/ShaderLib/normal_frag.glsl",