super-three 0.147.1 → 0.152.0

package/examples/jsm/nodes/shadernode/ShaderNodeBaseElements.js

@@ -1,301 +0,0 @@
-// core
-//import ArrayUniformNode from '../core/ArrayUniformNode.js';
-import AttributeNode from '../core/AttributeNode.js';
-import BypassNode from '../core/BypassNode.js';
-import CodeNode from '../core/CodeNode.js';
-import ContextNode from '../core/ContextNode.js';
-import ExpressionNode from '../core/ExpressionNode.js';
-import FunctionCallNode from '../core/FunctionCallNode.js';
-import FunctionNode from '../core/FunctionNode.js';
-import InstanceIndexNode from '../core/InstanceIndexNode.js';
-import PropertyNode from '../core/PropertyNode.js';
-import UniformNode from '../core/UniformNode.js';
-import VarNode from '../core/VarNode.js';
-import VaryingNode from '../core/VaryingNode.js';
-
-// accessors
-import BitangentNode from '../accessors/BitangentNode.js';
-import BufferNode from '../accessors/BufferNode.js';
-import CameraNode from '../accessors/CameraNode.js';
-import MaterialNode from '../accessors/MaterialNode.js';
-import MaterialReferenceNode from '../accessors/MaterialReferenceNode.js';
-import ModelViewProjectionNode from '../accessors/ModelViewProjectionNode.js';
-import NormalNode from '../accessors/NormalNode.js';
-import ModelNode from '../accessors/ModelNode.js';
-import PointUVNode from '../accessors/PointUVNode.js';
-import PositionNode from '../accessors/PositionNode.js';
-import ReferenceNode from '../accessors/ReferenceNode.js';
-import StorageBufferNode from '../accessors/StorageBufferNode.js';
-import TangentNode from '../accessors/TangentNode.js';
-import TextureNode from '../accessors/TextureNode.js';
-import UserDataNode from '../accessors/UserDataNode.js';
-import UVNode from '../accessors/UVNode.js';
-
-// display
-import FrontFacingNode from '../display/FrontFacingNode.js';
-
-// gpgpu
-import ComputeNode from '../gpgpu/ComputeNode.js';
-
-// math
-import MathNode from '../math/MathNode.js';
-import OperatorNode from '../math/OperatorNode.js';
-import CondNode from '../math/CondNode.js';
-
-// utils
-import ArrayElementNode from '../utils/ArrayElementNode.js';
-import ConvertNode from '../utils/ConvertNode.js';
-
-// shader node utils
-import { ShaderNode, nodeObject, nodeObjects, nodeArray, nodeProxy, nodeImmutable, ConvertType, getConstNodeType, cacheMaps } from './ShaderNode.js';
-
-// shader node base
-
-export { ShaderNode, nodeObject, nodeObjects, nodeArray, nodeProxy, nodeImmutable };
-
-export const color = new ConvertType( 'color' );
-
-export const float = new ConvertType( 'float', cacheMaps.float );
-export const int = new ConvertType( 'int', cacheMaps.int );
-export const uint = new ConvertType( 'uint', cacheMaps.uint );
-export const bool = new ConvertType( 'bool', cacheMaps.bool );
-
-export const vec2 = new ConvertType( 'vec2' );
-export const ivec2 = new ConvertType( 'ivec2' );
-export const uvec2 = new ConvertType( 'uvec2' );
-export const bvec2 = new ConvertType( 'bvec2' );
-
-export const vec3 = new ConvertType( 'vec3' );
-export const ivec3 = new ConvertType( 'ivec3' );
-export const uvec3 = new ConvertType( 'uvec3' );
-export const bvec3 = new ConvertType( 'bvec3' );
-
-export const vec4 = new ConvertType( 'vec4' );
-export const ivec4 = new ConvertType( 'ivec4' );
-export const uvec4 = new ConvertType( 'uvec4' );
-export const bvec4 = new ConvertType( 'bvec4' );
-
-export const mat3 = new ConvertType( 'mat3' );
-export const imat3 = new ConvertType( 'imat3' );
-export const umat3 = new ConvertType( 'umat3' );
-export const bmat3 = new ConvertType( 'bmat3' );
-
-export const mat4 = new ConvertType( 'mat4' );
-export const imat4 = new ConvertType( 'imat4' );
-export const umat4 = new ConvertType( 'umat4' );
-export const bmat4 = new ConvertType( 'bmat4' );
-
-// core
-
-// @TODO: ArrayUniformNode
-
-export const func = ( code, includes ) => {
-
-	const node = nodeObject( new FunctionNode( code, includes ) );
-
-	const call = node.call.bind( node );
-	node.call = ( ...params ) => nodeObject( call( params.length > 1 || params[ 0 ]?.isNode === true ? nodeArray( params ) : nodeObjects( params[ 0 ] ) ) );
-
-	return node;
-
-};
-
-export const uniform = ( nodeOrType ) => {
-
-	const nodeType = getConstNodeType( nodeOrType );
-
-	// @TODO: get ConstNode from .traverse() in the future
-	const value = nodeOrType.isNode === true ? nodeOrType.node?.value || nodeOrType.value : nodeOrType;
-
-	return nodeObject( new UniformNode( value, nodeType ) );
-
-};
-
-export const fn = ( code, includes ) => func( code, includes ).call;
-
-export const attribute = ( name, nodeType ) => nodeObject( new AttributeNode( name, nodeType ) );
-export const property = ( name, nodeOrType ) => nodeObject( new PropertyNode( name, getConstNodeType( nodeOrType ) ) );
-
-export const convert = ( node, types ) => nodeObject( new ConvertNode( nodeObject( node ), types ) );
-
-export const bypass = nodeProxy( BypassNode );
-export const code = nodeProxy( CodeNode );
-export const context = nodeProxy( ContextNode );
-export const expression = nodeProxy( ExpressionNode );
-export const call = nodeProxy( FunctionCallNode );
-export const instanceIndex = nodeImmutable( InstanceIndexNode );
-export const label = nodeProxy( VarNode );
-export const temp = label;
-export const varying = nodeProxy( VaryingNode );
-
-// math
-
-export const EPSILON = float( 1e-6 );
-export const INFINITY = float( 1e6 );
-
-export const cond = nodeProxy( CondNode );
-
-export const add = nodeProxy( OperatorNode, '+' );
-export const sub = nodeProxy( OperatorNode, '-' );
-export const mul = nodeProxy( OperatorNode, '*' );
-export const div = nodeProxy( OperatorNode, '/' );
-export const remainder = nodeProxy( OperatorNode, '%' );
-export const equal = nodeProxy( OperatorNode, '==' );
-export const assign = nodeProxy( OperatorNode, '=' );
-export const lessThan = nodeProxy( OperatorNode, '<' );
-export const greaterThan = nodeProxy( OperatorNode, '>' );
-export const lessThanEqual = nodeProxy( OperatorNode, '<=' );
-export const greaterThanEqual = nodeProxy( OperatorNode, '>=' );
-export const and = nodeProxy( OperatorNode, '&&' );
-export const or = nodeProxy( OperatorNode, '||' );
-export const xor = nodeProxy( OperatorNode, '^^' );
-export const bitAnd = nodeProxy( OperatorNode, '&' );
-export const bitOr = nodeProxy( OperatorNode, '|' );
-export const bitXor = nodeProxy( OperatorNode, '^' );
-export const shiftLeft = nodeProxy( OperatorNode, '<<' );
-export const shiftRight = nodeProxy( OperatorNode, '>>' );
-
-export const radians = nodeProxy( MathNode, MathNode.RADIANS );
-export const degrees = nodeProxy( MathNode, MathNode.DEGREES );
-export const exp = nodeProxy( MathNode, MathNode.EXP );
-export const exp2 = nodeProxy( MathNode, MathNode.EXP2 );
-export const log = nodeProxy( MathNode, MathNode.LOG );
-export const log2 = nodeProxy( MathNode, MathNode.LOG2 );
-export const sqrt = nodeProxy( MathNode, MathNode.SQRT );
-export const inversesqrt = nodeProxy( MathNode, MathNode.INVERSE_SQRT );
-export const floor = nodeProxy( MathNode, MathNode.FLOOR );
-export const ceil = nodeProxy( MathNode, MathNode.CEIL );
-export const normalize = nodeProxy( MathNode, MathNode.NORMALIZE );
-export const fract = nodeProxy( MathNode, MathNode.FRACT );
-export const sin = nodeProxy( MathNode, MathNode.SIN );
-export const cos = nodeProxy( MathNode, MathNode.COS );
-export const tan = nodeProxy( MathNode, MathNode.TAN );
-export const asin = nodeProxy( MathNode, MathNode.ASIN );
-export const acos = nodeProxy( MathNode, MathNode.ACOS );
-export const atan = nodeProxy( MathNode, MathNode.ATAN );
-export const abs = nodeProxy( MathNode, MathNode.ABS );
-export const sign = nodeProxy( MathNode, MathNode.SIGN );
-export const length = nodeProxy( MathNode, MathNode.LENGTH );
-export const negate = nodeProxy( MathNode, MathNode.NEGATE );
-export const invert = nodeProxy( MathNode, MathNode.INVERT );
-export const dFdx = nodeProxy( MathNode, MathNode.DFDX );
-export const dFdy = nodeProxy( MathNode, MathNode.DFDY );
-export const round = nodeProxy( MathNode, MathNode.ROUND );
-export const reciprocal = nodeProxy( MathNode, MathNode.RECIPROCAL );
-
-export const atan2 = nodeProxy( MathNode, MathNode.ATAN2 );
-export const min = nodeProxy( MathNode, MathNode.MIN );
-export const max = nodeProxy( MathNode, MathNode.MAX );
-export const mod = nodeProxy( MathNode, MathNode.MOD );
-export const step = nodeProxy( MathNode, MathNode.STEP );
-export const reflect = nodeProxy( MathNode, MathNode.REFLECT );
-export const distance = nodeProxy( MathNode, MathNode.DISTANCE );
-export const dot = nodeProxy( MathNode, MathNode.DOT );
-export const cross = nodeProxy( MathNode, MathNode.CROSS );
-export const pow = nodeProxy( MathNode, MathNode.POW );
-export const pow2 = nodeProxy( MathNode, MathNode.POW, 2 );
-export const pow3 = nodeProxy( MathNode, MathNode.POW, 3 );
-export const pow4 = nodeProxy( MathNode, MathNode.POW, 4 );
-export const transformDirection = nodeProxy( MathNode, MathNode.TRANSFORM_DIRECTION );
-
-export const mix = nodeProxy( MathNode, MathNode.MIX );
-export const clamp = ( value, low = 0, high = 1 ) => nodeObject( new MathNode( MathNode.CLAMP, nodeObject( value ), nodeObject( low ), nodeObject( high ) ) );
-export const refract = nodeProxy( MathNode, MathNode.REFRACT );
-export const smoothstep = nodeProxy( MathNode, MathNode.SMOOTHSTEP );
-export const faceforward = nodeProxy( MathNode, MathNode.FACEFORWARD );
-
-// accessors
-
-export const buffer = ( value, nodeOrType, count ) => nodeObject( new BufferNode( value, getConstNodeType( nodeOrType ), count ) );
-export const storage = ( value, nodeOrType, count ) => nodeObject( new StorageBufferNode( value, getConstNodeType( nodeOrType ), count ) );
-
-export const cameraProjectionMatrix = nodeImmutable( CameraNode, CameraNode.PROJECTION_MATRIX );
-export const cameraViewMatrix = nodeImmutable( CameraNode, CameraNode.VIEW_MATRIX );
-export const cameraNormalMatrix = nodeImmutable( CameraNode, CameraNode.NORMAL_MATRIX );
-export const cameraWorldMatrix = nodeImmutable( CameraNode, CameraNode.WORLD_MATRIX );
-export const cameraPosition = nodeImmutable( CameraNode, CameraNode.POSITION );
-
-export const materialAlphaTest = nodeImmutable( MaterialNode, MaterialNode.ALPHA_TEST );
-export const materialColor = nodeImmutable( MaterialNode, MaterialNode.COLOR );
-export const materialEmissive = nodeImmutable( MaterialNode, MaterialNode.EMISSIVE );
-export const materialOpacity = nodeImmutable( MaterialNode, MaterialNode.OPACITY );
-//export const materialSpecular = nodeImmutable( MaterialNode, MaterialNode.SPECULAR );
-export const materialRoughness = nodeImmutable( MaterialNode, MaterialNode.ROUGHNESS );
-export const materialMetalness = nodeImmutable( MaterialNode, MaterialNode.METALNESS );
-export const materialRotation = nodeImmutable( MaterialNode, MaterialNode.ROTATION );
-
-export const diffuseColor = nodeImmutable( PropertyNode, 'DiffuseColor', 'vec4' );
-export const roughness = nodeImmutable( PropertyNode, 'Roughness', 'float' );
-export const metalness = nodeImmutable( PropertyNode, 'Metalness', 'float' );
-export const alphaTest = nodeImmutable( PropertyNode, 'AlphaTest', 'float' );
-export const specularColor = nodeImmutable( PropertyNode, 'SpecularColor', 'color' );
-
-export const reference = ( name, nodeOrType, object ) => nodeObject( new ReferenceNode( name, getConstNodeType( nodeOrType ), object ) );
-export const materialReference = ( name, nodeOrType, material ) => nodeObject( new MaterialReferenceNode( name, getConstNodeType( nodeOrType ), material ) );
-export const userData = ( name, inputType, userData ) => nodeObject( new UserDataNode( name, inputType, userData ) );
-
-export const modelViewProjection = nodeProxy( ModelViewProjectionNode );
-
-export const normalGeometry = nodeImmutable( NormalNode, NormalNode.GEOMETRY );
-export const normalLocal = nodeImmutable( NormalNode, NormalNode.LOCAL );
-export const normalView = nodeImmutable( NormalNode, NormalNode.VIEW );
-export const normalWorld = nodeImmutable( NormalNode, NormalNode.WORLD );
-export const transformedNormalView = nodeImmutable( VarNode, normalView, 'TransformedNormalView' );
-export const transformedNormalWorld = normalize( transformDirection( transformedNormalView, cameraViewMatrix ) );
-
-export const tangentGeometry = nodeImmutable( TangentNode, TangentNode.GEOMETRY );
-export const tangentLocal = nodeImmutable( TangentNode, TangentNode.LOCAL );
-export const tangentView = nodeImmutable( TangentNode, TangentNode.VIEW );
-export const tangentWorld = nodeImmutable( TangentNode, TangentNode.WORLD );
-export const transformedTangentView = nodeImmutable( VarNode, tangentView, 'TransformedTangentView' );
-export const transformedTangentWorld = normalize( transformDirection( transformedTangentView, cameraViewMatrix ) );
-
-export const bitangentGeometry = nodeImmutable( BitangentNode, BitangentNode.GEOMETRY );
-export const bitangentLocal = nodeImmutable( BitangentNode, BitangentNode.LOCAL );
-export const bitangentView = nodeImmutable( BitangentNode, BitangentNode.VIEW );
-export const bitangentWorld = nodeImmutable( BitangentNode, BitangentNode.WORLD );
-export const transformedBitangentView = normalize( mul( cross( transformedNormalView, transformedTangentView ), tangentGeometry.w ) );
-export const transformedBitangentWorld = normalize( transformDirection( transformedBitangentView, cameraViewMatrix ) );
-
-export const modelViewMatrix = nodeImmutable( ModelNode, ModelNode.VIEW_MATRIX );
-export const modelNormalMatrix = nodeImmutable( ModelNode, ModelNode.NORMAL_MATRIX );
-export const modelWorldMatrix = nodeImmutable( ModelNode, ModelNode.WORLD_MATRIX );
-export const modelPosition = nodeImmutable( ModelNode, ModelNode.POSITION );
-export const modelViewPosition = nodeImmutable( ModelNode, ModelNode.VIEW_POSITION );
-
-export const positionGeometry = nodeImmutable( PositionNode, PositionNode.GEOMETRY );
-export const positionLocal = nodeImmutable( PositionNode, PositionNode.LOCAL );
-export const positionWorld = nodeImmutable( PositionNode, PositionNode.WORLD );
-export const positionWorldDirection = nodeImmutable( PositionNode, PositionNode.WORLD_DIRECTION );
-export const positionView = nodeImmutable( PositionNode, PositionNode.VIEW );
-export const positionViewDirection = nodeImmutable( PositionNode, PositionNode.VIEW_DIRECTION );
-
-export const texture = nodeProxy( TextureNode );
-export const sampler = ( texture ) => nodeObject( new ConvertNode( texture.isNode === true ? texture : new TextureNode( texture ), 'sampler' ) );
-export const uv = ( ...params ) => nodeObject( new UVNode( ...params ) );
-export const pointUV = nodeImmutable( PointUVNode );
-
-// gpgpu
-
-export const compute = ( node, count, workgroupSize ) => nodeObject( new ComputeNode( nodeObject( node ), count, workgroupSize ) );
-
-// display
-
-export const frontFacing = nodeImmutable( FrontFacingNode );
-export const faceDirection = sub( mul( float( frontFacing ), 2 ), 1 );
-
-// lighting
-
-
-// utils
-
-export const element = nodeProxy( ArrayElementNode );
-
-// miscellaneous
-
-export const lumaCoeffs = vec3( 0.2125, 0.7154, 0.0721 );
-
-export const luminance = ( color, luma = lumaCoeffs ) => dot( color, luma );
-export const difference = ( a, b ) => abs( sub( a, b ) );
-export const dotNV = clamp( dot( transformedNormalView, positionViewDirection ) );
-export const TBNViewMatrix = mat3( tangentView, bitangentView, normalView );

package/examples/jsm/nodes/shadernode/ShaderNodeElements.js

@@ -1,149 +0,0 @@
-// accessors
-import CubeTextureNode from '../accessors/CubeTextureNode.js';
-import InstanceNode from '../accessors/InstanceNode.js';
-import ReflectVectorNode from '../accessors/ReflectVectorNode.js';
-import SkinningNode from '../accessors/SkinningNode.js';
-
-// display
-import BlendModeNode from '../display/BlendModeNode.js';
-import ColorAdjustmentNode from '../display/ColorAdjustmentNode.js';
-import ColorSpaceNode from '../display/ColorSpaceNode.js';
-import NormalMapNode from '../display/NormalMapNode.js';
-import PosterizeNode from '../display/PosterizeNode.js';
-import ToneMappingNode from '../display/ToneMappingNode.js';
-import ViewportNode from '../display/ViewportNode.js';
-
-// lighting
-import LightsNode from '../lighting/LightsNode.js';
-//import LightingNode from '../lighting/LightingNode.js';
-import LightingContextNode from '../lighting/LightingContextNode.js';
-
-// utils
-import EquirectUVNode from '../utils/EquirectUVNode.js';
-import MatcapUVNode from '../utils/MatcapUVNode.js';
-import MaxMipLevelNode from '../utils/MaxMipLevelNode.js';
-import OscNode from '../utils/OscNode.js';
-import RemapNode from '../utils/RemapNode.js';
-import RotateUVNode from '../utils/RotateUVNode.js';
-import SpriteSheetUVNode from '../utils/SpriteSheetUVNode.js';
-import TimerNode from '../utils/TimerNode.js';
-import TriplanarTexturesNode from '../utils/TriplanarTexturesNode.js';
-
-// geometry
-import RangeNode from '../geometry/RangeNode.js';
-
-// procedural
-import CheckerNode from '../procedural/CheckerNode.js';
-
-// fog
-import FogNode from '../fog/FogNode.js';
-import FogRangeNode from '../fog/FogRangeNode.js';
-
-// shader node utils
-import { nodeObject, nodeProxy, nodeImmutable } from './ShaderNode.js';
-
-//
-// Node Material Shader Syntax
-//
-
-// shader node base
-
-export * from './ShaderNodeBaseElements.js';
-
-// functions
-
-export { default as BRDF_GGX } from '../functions/BSDF/BRDF_GGX.js'; // see https://github.com/tc39/proposal-export-default-from
-export { default as BRDF_Lambert } from '../functions/BSDF/BRDF_Lambert.js';
-export { default as D_GGX } from '../functions/BSDF/D_GGX.js';
-export { default as DFGApprox } from '../functions/BSDF/DFGApprox.js';
-export { default as F_Schlick } from '../functions/BSDF/F_Schlick.js';
-export { default as V_GGX_SmithCorrelated } from '../functions/BSDF/V_GGX_SmithCorrelated.js';
-
-export { default as getDistanceAttenuation } from '../functions/light/getDistanceAttenuation.js';
-
-export { default as getGeometryRoughness } from '../functions/material/getGeometryRoughness.js';
-export { default as getRoughness } from '../functions/material/getRoughness.js';
-
-export { default as PhysicalLightingModel } from '../functions/PhysicalLightingModel.js';
-
-// accessors
-
-export const cubeTexture = nodeProxy( CubeTextureNode );
-
-export const instance = nodeProxy( InstanceNode );
-
-export const reflectVector = nodeImmutable( ReflectVectorNode );
-
-export const skinning = nodeProxy( SkinningNode );
-
-// display
-
-export const burn = nodeProxy( BlendModeNode, BlendModeNode.BURN );
-export const dodge = nodeProxy( BlendModeNode, BlendModeNode.DODGE );
-export const overlay = nodeProxy( BlendModeNode, BlendModeNode.OVERLAY );
-export const screen = nodeProxy( BlendModeNode, BlendModeNode.SCREEN );
-
-export const saturation = nodeProxy( ColorAdjustmentNode, ColorAdjustmentNode.SATURATION );
-export const vibrance = nodeProxy( ColorAdjustmentNode, ColorAdjustmentNode.VIBRANCE );
-export const hue = nodeProxy( ColorAdjustmentNode, ColorAdjustmentNode.HUE );
-
-export const colorSpace = ( node, encoding ) => nodeObject( new ColorSpaceNode( null, nodeObject( node ) ).fromEncoding( encoding ) );
-export const normalMap = nodeProxy( NormalMapNode );
-export const toneMapping = ( mapping, exposure, color ) => nodeObject( new ToneMappingNode( mapping, nodeObject( exposure ), nodeObject( color ) ) );
-
-export const posterize = nodeProxy( PosterizeNode );
-
-export const viewportCoordinate = nodeImmutable( ViewportNode, ViewportNode.COORDINATE );
-export const viewportResolution = nodeImmutable( ViewportNode, ViewportNode.RESOLUTION );
-export const viewportTopLeft = nodeImmutable( ViewportNode, ViewportNode.TOP_LEFT );
-export const viewportBottomLeft = nodeImmutable( ViewportNode, ViewportNode.BOTTOM_LEFT );
-export const viewportTopRight = nodeImmutable( ViewportNode, ViewportNode.TOP_RIGHT );
-export const viewportBottomRight = nodeImmutable( ViewportNode, ViewportNode.BOTTOM_RIGHT );
-
-// lighting
-
-//export const lighting = nodeProxy( LightingNode ); // abstract
-//export const light; // still needs to be added
-export const lights = ( lights ) => nodeObject( new LightsNode().fromLights( lights ) );
-export const lightingContext = nodeProxy( LightingContextNode );
-
-// utils
-
-export const matcapUV = nodeImmutable( MatcapUVNode );
-export const equirectUV = nodeProxy( EquirectUVNode );
-
-export const maxMipLevel = nodeProxy( MaxMipLevelNode );
-
-export const oscSine = nodeProxy( OscNode, OscNode.SINE );
-export const oscSquare = nodeProxy( OscNode, OscNode.SQUARE );
-export const oscTriangle = nodeProxy( OscNode, OscNode.TRIANGLE );
-export const oscSawtooth = nodeProxy( OscNode, OscNode.SAWTOOTH );
-
-export const remap = nodeProxy( RemapNode, null, null, { doClamp: false } );
-export const remapClamp = nodeProxy( RemapNode );
-
-export const rotateUV = nodeProxy( RotateUVNode );
-
-export const spritesheetUV = nodeProxy( SpriteSheetUVNode );
-
-// @TODO: add supports to use node in timeScale
-export const timerLocal = ( timeScale, value = 0 ) => nodeObject( new TimerNode( TimerNode.LOCAL, timeScale, value ) );
-export const timerGlobal = ( timeScale, value = 0 ) => nodeObject( new TimerNode( TimerNode.GLOBAL, timeScale, value ) );
-export const timerDelta = ( timeScale, value = 0 ) => nodeObject( new TimerNode( TimerNode.DELTA, timeScale, value ) );
-export const frameId = nodeImmutable( TimerNode, TimerNode.FRAME );
-
-export const triplanarTextures = nodeProxy( TriplanarTexturesNode );
-export const triplanarTexture = ( texture, ...params ) => triplanarTextures( texture, texture, texture, ...params );
-
-// geometry
-
-export const range = ( min, max ) => nodeObject( new RangeNode( min, max ) );
-
-// procedural
-
-export const checker = nodeProxy( CheckerNode );
-
-// fog
-
-export const fog = nodeProxy( FogNode );
-export const rangeFog = nodeProxy( FogRangeNode );

package/examples/jsm/objects/GroundProjectedEnv.js

@@ -1,186 +0,0 @@
-import { Mesh, IcosahedronGeometry, ShaderMaterial, DoubleSide } from 'three';
-
-/**
- * Ground projected env map adapted from @react-three/drei.
- * https://github.com/pmndrs/drei/blob/master/src/core/Environment.tsx
- */
-export class GroundProjectedEnv extends Mesh {
-
-	constructor( texture, options ) {
-
-		const isCubeMap = texture.isCubeTexture;
-		const w =
-			( isCubeMap ? texture.image[ 0 ]?.width : texture.image.width ) ?? 1024;
-		const cubeSize = w / 4;
-		const _lodMax = Math.floor( Math.log2( cubeSize ) );
-		const _cubeSize = Math.pow( 2, _lodMax );
-		const width = 3 * Math.max( _cubeSize, 16 * 7 );
-		const height = 4 * _cubeSize;
-
-		const defines = [
-			isCubeMap ? '#define ENVMAP_TYPE_CUBE' : '',
-			`#define CUBEUV_TEXEL_WIDTH ${1.0 / width}`,
-			`#define CUBEUV_TEXEL_HEIGHT ${1.0 / height}`,
-			`#define CUBEUV_MAX_MIP ${_lodMax}.0`,
-		];
-
-		const vertexShader = /* glsl */ `
-        varying vec3 vWorldPosition;
-
-        void main() 
-        {
-
-            vec4 worldPosition = ( modelMatrix * vec4( position, 1.0 ) );
-            vWorldPosition = worldPosition.xyz;
-            
-            gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-        }
-        `;
-		const fragmentShader = defines.join( '\n' ) + /* glsl */ `
-        #define ENVMAP_TYPE_CUBE_UV
-
-        varying vec3 vWorldPosition;
-
-        uniform float radius;
-        uniform float height;
-        uniform float angle;
-
-        #ifdef ENVMAP_TYPE_CUBE
-
-            uniform samplerCube map;
-
-        #else
-
-            uniform sampler2D map;
-
-        #endif
-
-        // From: https://www.shadertoy.com/view/4tsBD7
-        float diskIntersectWithBackFaceCulling( vec3 ro, vec3 rd, vec3 c, vec3 n, float r ) 
-        {
-
-            float d = dot ( rd, n );
-            
-            if( d > 0.0 ) { return 1e6; }
-            
-            vec3  o = ro - c;
-            float t = - dot( n, o ) / d;
-            vec3  q = o + rd * t;
-            
-            return ( dot( q, q ) < r * r ) ? t : 1e6;
-
-        }
-
-        // From: https://www.iquilezles.org/www/articles/intersectors/intersectors.htm
-        float sphereIntersect( vec3 ro, vec3 rd, vec3 ce, float ra ) 
-        {
-
-            vec3 oc = ro - ce;
-            float b = dot( oc, rd );
-            float c = dot( oc, oc ) - ra * ra;
-            float h = b * b - c;
-            
-            if( h < 0.0 ) { return -1.0; }
-            
-            h = sqrt( h );
-            
-            return - b + h;
-
-        }
-
-        vec3 project() 
-        {
-
-            vec3 p = normalize( vWorldPosition );
-            vec3 camPos = cameraPosition;
-            camPos.y -= height;
-
-            float intersection = sphereIntersect( camPos, p, vec3( 0.0 ), radius );
-            if( intersection > 0.0 ) {
-                
-                vec3 h = vec3( 0.0, - height, 0.0 );
-                float intersection2 = diskIntersectWithBackFaceCulling( camPos, p, h, vec3( 0.0, 1.0, 0.0 ), radius );
-                p = ( camPos + min( intersection, intersection2 ) * p ) / radius;
-
-            } else {
-
-                p = vec3( 0.0, 1.0, 0.0 );
-
-            }
-
-            return p;
-
-        }
-
-        #include <common>
-        #include <cube_uv_reflection_fragment>
-
-        void main() 
-        {
-
-            vec3 projectedWorldPosition = project();
-            
-            #ifdef ENVMAP_TYPE_CUBE
-
-                vec3 outcolor = textureCube( map, projectedWorldPosition ).rgb;
-
-            #else
-
-                vec3 direction = normalize( projectedWorldPosition );
-                vec2 uv = equirectUv( direction );
-                vec3 outcolor = texture2D( map, uv ).rgb;
-
-            #endif
-
-            gl_FragColor = vec4( outcolor, 1.0 );
-
-            #include <tonemapping_fragment>
-            #include <encodings_fragment>
-
-        }
-        `;
-
-		const uniforms = {
-			map: { value: texture },
-			height: { value: options?.height || 15 },
-			radius: { value: options?.radius || 100 },
-		};
-
-		const geometry = new IcosahedronGeometry( 1, 16 );
-		const material = new ShaderMaterial( {
-			uniforms,
-			fragmentShader,
-			vertexShader,
-			side: DoubleSide,
-		} );
-
-		super( geometry, material );
-
-	}
-
-	set radius( radius ) {
-
-		this.material.uniforms.radius.value = radius;
-
-	}
-
-	get radius() {
-
-		return this.material.uniforms.radius.value;
-
-	}
-
-	set height( height ) {
-
-		this.material.uniforms.height.value = height;
-
-	}
-
-	get height() {
-
-		return this.material.uniforms.height.value;
-
-	}
-
-}

package/examples/jsm/renderers/webgpu/WebGPUObjects.js

@@ -1,36 +0,0 @@
-class WebGPUObjects {
-
-	constructor( geometries, info ) {
-
-		this.geometries = geometries;
-		this.info = info;
-
-		this.updateMap = new WeakMap();
-
-	}
-
-	update( object ) {
-
-		const geometry = object.geometry;
-		const updateMap = this.updateMap;
-		const frame = this.info.render.frame;
-
-		if ( this.geometries.has( geometry ) === false || updateMap.get( geometry ) !== frame ) {
-
-			this.geometries.update( geometry );
-
-			updateMap.set( geometry, frame );
-
-		}
-
-	}
-
-	dispose() {
-
-		this.updateMap = new WeakMap();
-
-	}
-
-}
-
-export default WebGPUObjects;

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

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