@anov/3d 0.0.1 → 0.0.2

package/examples/jsm/materials/MeshGouraudMaterial.js

@@ -0,0 +1,420 @@
+/**
+ * MeshGouraudMaterial
+ *
+ * Lambert illumination model with Gouraud (per-vertex) shading
+ *
+ */
+
+import { UniformsUtils, UniformsLib, ShaderMaterial, Color, MultiplyOperation } from 'three';
+
+const GouraudShader = {
+
+	uniforms: UniformsUtils.merge( [
+		UniformsLib.common,
+		UniformsLib.specularmap,
+		UniformsLib.envmap,
+		UniformsLib.aomap,
+		UniformsLib.lightmap,
+		UniformsLib.emissivemap,
+		UniformsLib.fog,
+		UniformsLib.lights,
+		{
+			emissive: { value: new Color( 0x000000 ) }
+		}
+	] ),
+
+	vertexShader: /* glsl */`
+
+		#define GOURAUD
+
+		varying vec3 vLightFront;
+		varying vec3 vIndirectFront;
+
+		#ifdef DOUBLE_SIDED
+			varying vec3 vLightBack;
+			varying vec3 vIndirectBack;
+		#endif
+
+		#include <common>
+		#include <uv_pars_vertex>
+		#include <envmap_pars_vertex>
+		#include <bsdfs>
+		#include <lights_pars_begin>
+		#include <color_pars_vertex>
+		#include <fog_pars_vertex>
+		#include <morphtarget_pars_vertex>
+		#include <skinning_pars_vertex>
+		#include <shadowmap_pars_vertex>
+		#include <logdepthbuf_pars_vertex>
+		#include <clipping_planes_pars_vertex>
+
+		void main() {
+
+			#include <uv_vertex>
+			#include <color_vertex>
+			#include <morphcolor_vertex>
+
+			#include <beginnormal_vertex>
+			#include <morphnormal_vertex>
+			#include <skinbase_vertex>
+			#include <skinnormal_vertex>
+			#include <defaultnormal_vertex>
+
+			#include <begin_vertex>
+			#include <morphtarget_vertex>
+			#include <skinning_vertex>
+			#include <project_vertex>
+			#include <logdepthbuf_vertex>
+			#include <clipping_planes_vertex>
+
+			#include <worldpos_vertex>
+			#include <envmap_vertex>
+
+			// inlining legacy <lights_lambert_vertex>
+
+			vec3 diffuse = vec3( 1.0 );
+
+			GeometricContext geometry;
+			geometry.position = mvPosition.xyz;
+			geometry.normal = normalize( transformedNormal );
+			geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );
+
+			GeometricContext backGeometry;
+			backGeometry.position = geometry.position;
+			backGeometry.normal = -geometry.normal;
+			backGeometry.viewDir = geometry.viewDir;
+
+			vLightFront = vec3( 0.0 );
+			vIndirectFront = vec3( 0.0 );
+			#ifdef DOUBLE_SIDED
+				vLightBack = vec3( 0.0 );
+				vIndirectBack = vec3( 0.0 );
+			#endif
+
+			IncidentLight directLight;
+			float dotNL;
+			vec3 directLightColor_Diffuse;
+
+			vIndirectFront += getAmbientLightIrradiance( ambientLightColor );
+
+			vIndirectFront += getLightProbeIrradiance( lightProbe, geometry.normal );
+
+			#ifdef DOUBLE_SIDED
+
+				vIndirectBack += getAmbientLightIrradiance( ambientLightColor );
+
+				vIndirectBack += getLightProbeIrradiance( lightProbe, backGeometry.normal );
+
+			#endif
+
+			#if NUM_POINT_LIGHTS > 0
+
+				#pragma unroll_loop_start
+				for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
+
+					getPointLightInfo( pointLights[ i ], geometry, directLight );
+
+					dotNL = dot( geometry.normal, directLight.direction );
+					directLightColor_Diffuse = directLight.color;
+
+					vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
+
+					#ifdef DOUBLE_SIDED
+
+						vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
+
+					#endif
+
+				}
+				#pragma unroll_loop_end
+
+			#endif
+
+			#if NUM_SPOT_LIGHTS > 0
+
+				#pragma unroll_loop_start
+				for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
+
+					getSpotLightInfo( spotLights[ i ], geometry, directLight );
+
+					dotNL = dot( geometry.normal, directLight.direction );
+					directLightColor_Diffuse = directLight.color;
+
+					vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
+
+					#ifdef DOUBLE_SIDED
+
+						vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
+
+					#endif
+				}
+				#pragma unroll_loop_end
+
+			#endif
+
+			#if NUM_DIR_LIGHTS > 0
+
+				#pragma unroll_loop_start
+				for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
+
+					getDirectionalLightInfo( directionalLights[ i ], geometry, directLight );
+
+					dotNL = dot( geometry.normal, directLight.direction );
+					directLightColor_Diffuse = directLight.color;
+
+					vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
+
+					#ifdef DOUBLE_SIDED
+
+						vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
+
+					#endif
+
+				}
+				#pragma unroll_loop_end
+
+			#endif
+
+			#if NUM_HEMI_LIGHTS > 0
+
+				#pragma unroll_loop_start
+				for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
+
+					vIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );
+
+					#ifdef DOUBLE_SIDED
+
+						vIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry.normal );
+
+					#endif
+
+				}
+				#pragma unroll_loop_end
+
+			#endif
+
+			#include <shadowmap_vertex>
+			#include <fog_vertex>
+
+		}`,
+
+	fragmentShader: /* glsl */`
+
+		#define GOURAUD
+
+		uniform vec3 diffuse;
+		uniform vec3 emissive;
+		uniform float opacity;
+
+		varying vec3 vLightFront;
+		varying vec3 vIndirectFront;
+
+		#ifdef DOUBLE_SIDED
+			varying vec3 vLightBack;
+			varying vec3 vIndirectBack;
+		#endif
+
+		#include <common>
+		#include <packing>
+		#include <dithering_pars_fragment>
+		#include <color_pars_fragment>
+		#include <uv_pars_fragment>
+		#include <map_pars_fragment>
+		#include <alphamap_pars_fragment>
+		#include <alphatest_pars_fragment>
+		#include <aomap_pars_fragment>
+		#include <lightmap_pars_fragment>
+		#include <emissivemap_pars_fragment>
+		#include <envmap_common_pars_fragment>
+		#include <envmap_pars_fragment>
+		#include <bsdfs>
+		#include <lights_pars_begin>
+		#include <fog_pars_fragment>
+		#include <shadowmap_pars_fragment>
+		#include <shadowmask_pars_fragment>
+		#include <specularmap_pars_fragment>
+		#include <logdepthbuf_pars_fragment>
+		#include <clipping_planes_pars_fragment>
+
+		void main() {
+
+			#include <clipping_planes_fragment>
+
+			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 <emissivemap_fragment>
+
+			// accumulation
+
+			#ifdef DOUBLE_SIDED
+
+				reflectedLight.indirectDiffuse += ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;
+
+			#else
+
+				reflectedLight.indirectDiffuse += vIndirectFront;
+
+			#endif
+
+			#include <lightmap_fragment>
+
+			reflectedLight.indirectDiffuse *= BRDF_Lambert( diffuseColor.rgb );
+
+			#ifdef DOUBLE_SIDED
+
+				reflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;
+
+			#else
+
+				reflectedLight.directDiffuse = vLightFront;
+
+			#endif
+
+			reflectedLight.directDiffuse *= BRDF_Lambert( diffuseColor.rgb ) * getShadowMask();
+
+			// modulation
+
+			#include <aomap_fragment>
+
+			vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
+
+			#include <envmap_fragment>
+
+			#include <opaque_fragment>
+			#include <tonemapping_fragment>
+			#include <colorspace_fragment>
+			#include <fog_fragment>
+			#include <premultiplied_alpha_fragment>
+			#include <dithering_fragment>
+
+		}`
+
+};
+
+//
+
+class MeshGouraudMaterial extends ShaderMaterial {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isMeshGouraudMaterial = true;
+
+		this.type = 'MeshGouraudMaterial';
+
+		//this.color = new THREE.Color( 0xffffff ); // diffuse
+
+		//this.map = null;
+
+		//this.lightMap = null;
+		//this.lightMapIntensity = 1.0;
+
+		//this.aoMap = null;
+		//this.aoMapIntensity = 1.0;
+
+		//this.emissive = new THREE.Color( 0x000000 );
+		//this.emissiveIntensity = 1.0;
+		//this.emissiveMap = null;
+
+		//this.specularMap = null;
+
+		//this.alphaMap = null;
+
+		//this.envMap = null;
+		this.combine = MultiplyOperation; // combine has no uniform
+		//this.reflectivity = 1;
+		//this.refractionRatio = 0.98;
+
+		this.fog = false; // set to use scene fog
+		this.lights = true; // set to use scene lights
+		this.clipping = false; // set to use user-defined clipping planes
+
+		const shader = GouraudShader;
+
+		this.defines = Object.assign( {}, shader.defines );
+		this.uniforms = UniformsUtils.clone( shader.uniforms );
+		this.vertexShader = shader.vertexShader;
+		this.fragmentShader = shader.fragmentShader;
+
+		const exposePropertyNames = [
+			'map', 'lightMap', 'lightMapIntensity', 'aoMap', 'aoMapIntensity',
+			'emissive', 'emissiveIntensity', 'emissiveMap', 'specularMap', 'alphaMap',
+			'envMap', 'reflectivity', 'refractionRatio', 'opacity', 'diffuse'
+		];
+
+		for ( const propertyName of exposePropertyNames ) {
+
+			Object.defineProperty( this, propertyName, {
+
+				get: function () {
+
+					return this.uniforms[ propertyName ].value;
+
+				},
+
+				set: function ( value ) {
+
+					this.uniforms[ propertyName ].value = value;
+
+				}
+
+			} );
+
+		}
+
+		Object.defineProperty( this, 'color', Object.getOwnPropertyDescriptor( this, 'diffuse' ) );
+
+		this.setValues( parameters );
+
+	}
+
+	copy( source ) {
+
+		super.copy( source );
+
+		this.color.copy( source.color );
+
+		this.map = source.map;
+
+		this.lightMap = source.lightMap;
+		this.lightMapIntensity = source.lightMapIntensity;
+
+		this.aoMap = source.aoMap;
+		this.aoMapIntensity = source.aoMapIntensity;
+
+		this.emissive.copy( source.emissive );
+		this.emissiveMap = source.emissiveMap;
+		this.emissiveIntensity = source.emissiveIntensity;
+
+		this.specularMap = source.specularMap;
+
+		this.alphaMap = source.alphaMap;
+
+		this.envMap = source.envMap;
+		this.combine = source.combine;
+		this.reflectivity = source.reflectivity;
+		this.refractionRatio = source.refractionRatio;
+
+		this.wireframe = source.wireframe;
+		this.wireframeLinewidth = source.wireframeLinewidth;
+		this.wireframeLinecap = source.wireframeLinecap;
+		this.wireframeLinejoin = source.wireframeLinejoin;
+
+		this.fog = source.fog;
+
+		return this;
+
+	}
+
+}
+
+export { MeshGouraudMaterial };

package/examples/jsm/math/Capsule.js

@@ -0,0 +1,137 @@
+import {
+	Vector3
+} from 'three';
+
+const _v1 = new Vector3();
+const _v2 = new Vector3();
+const _v3 = new Vector3();
+
+const EPS = 1e-10;
+
+class Capsule {
+
+	constructor( start = new Vector3( 0, 0, 0 ), end = new Vector3( 0, 1, 0 ), radius = 1 ) {
+
+		this.start = start;
+		this.end = end;
+		this.radius = radius;
+
+	}
+
+	clone() {
+
+		return new Capsule( this.start.clone(), this.end.clone(), this.radius );
+
+	}
+
+	set( start, end, radius ) {
+
+		this.start.copy( start );
+		this.end.copy( end );
+		this.radius = radius;
+
+	}
+
+	copy( capsule ) {
+
+		this.start.copy( capsule.start );
+		this.end.copy( capsule.end );
+		this.radius = capsule.radius;
+
+	}
+
+	getCenter( target ) {
+
+		return target.copy( this.end ).add( this.start ).multiplyScalar( 0.5 );
+
+	}
+
+	translate( v ) {
+
+		this.start.add( v );
+		this.end.add( v );
+
+	}
+
+	checkAABBAxis( p1x, p1y, p2x, p2y, minx, maxx, miny, maxy, radius ) {
+
+		return (
+			( minx - p1x < radius || minx - p2x < radius ) &&
+			( p1x - maxx < radius || p2x - maxx < radius ) &&
+			( miny - p1y < radius || miny - p2y < radius ) &&
+			( p1y - maxy < radius || p2y - maxy < radius )
+		);
+
+	}
+
+	intersectsBox( box ) {
+
+		return (
+			this.checkAABBAxis(
+				this.start.x, this.start.y, this.end.x, this.end.y,
+				box.min.x, box.max.x, box.min.y, box.max.y,
+				this.radius ) &&
+			this.checkAABBAxis(
+				this.start.x, this.start.z, this.end.x, this.end.z,
+				box.min.x, box.max.x, box.min.z, box.max.z,
+				this.radius ) &&
+			this.checkAABBAxis(
+				this.start.y, this.start.z, this.end.y, this.end.z,
+				box.min.y, box.max.y, box.min.z, box.max.z,
+				this.radius )
+		);
+
+	}
+
+	lineLineMinimumPoints( line1, line2 ) {
+
+		const r = _v1.copy( line1.end ).sub( line1.start );
+		const s = _v2.copy( line2.end ).sub( line2.start );
+		const w = _v3.copy( line2.start ).sub( line1.start );
+
+		const a = r.dot( s ),
+			b = r.dot( r ),
+			c = s.dot( s ),
+			d = s.dot( w ),
+			e = r.dot( w );
+
+		let t1, t2;
+		const divisor = b * c - a * a;
+
+		if ( Math.abs( divisor ) < EPS ) {
+
+			const d1 = - d / c;
+			const d2 = ( a - d ) / c;
+
+			if ( Math.abs( d1 - 0.5 ) < Math.abs( d2 - 0.5 ) ) {
+
+				t1 = 0;
+				t2 = d1;
+
+			} else {
+
+				t1 = 1;
+				t2 = d2;
+
+			}
+
+		} else {
+
+			t1 = ( d * a + e * c ) / divisor;
+			t2 = ( t1 * a - d ) / c;
+
+		}
+
+		t2 = Math.max( 0, Math.min( 1, t2 ) );
+		t1 = Math.max( 0, Math.min( 1, t1 ) );
+
+		const point1 = r.multiplyScalar( t1 ).add( line1.start );
+		const point2 = s.multiplyScalar( t2 ).add( line2.start );
+
+		return [ point1, point2 ];
+
+	}
+
+}
+
+export { Capsule };

package/examples/jsm/math/ColorConverter.js

@@ -0,0 +1,36 @@
+import { MathUtils } from 'three';
+
+const _hsl = {};
+
+class ColorConverter {
+
+	static setHSV( color, h, s, v ) {
+
+		// https://gist.github.com/xpansive/1337890#file-index-js
+
+		h = MathUtils.euclideanModulo( h, 1 );
+		s = MathUtils.clamp( s, 0, 1 );
+		v = MathUtils.clamp( v, 0, 1 );
+
+		return color.setHSL( h, ( s * v ) / ( ( h = ( 2 - s ) * v ) < 1 ? h : ( 2 - h ) ), h * 0.5 );
+
+	}
+
+	static getHSV( color, target ) {
+
+		color.getHSL( _hsl );
+
+		// based on https://gist.github.com/xpansive/1337890#file-index-js
+		_hsl.s *= ( _hsl.l < 0.5 ) ? _hsl.l : ( 1 - _hsl.l );
+
+		target.h = _hsl.h;
+		target.s = 2 * _hsl.s / ( _hsl.l + _hsl.s );
+		target.v = _hsl.l + _hsl.s;
+
+		return target;
+
+	}
+
+}
+
+export { ColorConverter };