You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
794 lines
22 KiB
794 lines
22 KiB
<!DOCTYPE html>
|
|
<html lang="en">
|
|
<head>
|
|
<title>three.js webgl - lightning strike</title>
|
|
<meta charset="utf-8">
|
|
<meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
|
|
<link type="text/css" rel="stylesheet" href="main.css">
|
|
</head>
|
|
<body>
|
|
|
|
<div id="container"></div>
|
|
<div id="info"><a href="https://threejs.org" target="_blank" rel="noopener">three.js</a> webgl - lightning strike</div>
|
|
|
|
<!-- Import maps polyfill -->
|
|
<!-- Remove this when import maps will be widely supported -->
|
|
<script async src="https://unpkg.com/es-module-shims@1.3.6/dist/es-module-shims.js"></script>
|
|
|
|
<script type="importmap">
|
|
{
|
|
"imports": {
|
|
"three": "../build/three.module.js",
|
|
"three/addons/": "./jsm/"
|
|
}
|
|
}
|
|
</script>
|
|
|
|
<script type="module">
|
|
|
|
import * as THREE from 'three';
|
|
|
|
import Stats from 'three/addons/libs/stats.module.js';
|
|
import { GUI } from 'three/addons/libs/lil-gui.module.min.js';
|
|
|
|
import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
|
|
import { LightningStrike } from 'three/addons/geometries/LightningStrike.js';
|
|
import { LightningStorm } from 'three/addons/objects/LightningStorm.js';
|
|
import { EffectComposer } from 'three/addons/postprocessing/EffectComposer.js';
|
|
import { RenderPass } from 'three/addons/postprocessing/RenderPass.js';
|
|
import { OutlinePass } from 'three/addons/postprocessing/OutlinePass.js';
|
|
|
|
let container, stats;
|
|
|
|
let scene, renderer, composer, gui;
|
|
|
|
let currentSceneIndex = 0;
|
|
|
|
let currentTime = 0;
|
|
|
|
const sceneCreators = [
|
|
createConesScene,
|
|
createPlasmaBallScene,
|
|
createStormScene
|
|
];
|
|
|
|
const clock = new THREE.Clock();
|
|
|
|
const raycaster = new THREE.Raycaster();
|
|
const mouse = new THREE.Vector2();
|
|
|
|
init();
|
|
animate();
|
|
|
|
function init() {
|
|
|
|
container = document.getElementById( 'container' );
|
|
|
|
renderer = new THREE.WebGLRenderer();
|
|
renderer.setPixelRatio( window.devicePixelRatio );
|
|
renderer.setSize( window.innerWidth, window.innerHeight );
|
|
renderer.outputEncoding = THREE.sRGBEncoding;
|
|
|
|
container.appendChild( renderer.domElement );
|
|
|
|
composer = new EffectComposer( renderer );
|
|
|
|
stats = new Stats();
|
|
container.appendChild( stats.dom );
|
|
|
|
window.addEventListener( 'resize', onWindowResize );
|
|
|
|
createScene();
|
|
|
|
}
|
|
|
|
function createScene() {
|
|
|
|
scene = sceneCreators[ currentSceneIndex ]();
|
|
|
|
createGUI();
|
|
|
|
}
|
|
|
|
function onWindowResize() {
|
|
|
|
scene.userData.camera.aspect = window.innerWidth / window.innerHeight;
|
|
scene.userData.camera.updateProjectionMatrix();
|
|
|
|
renderer.setSize( window.innerWidth, window.innerHeight );
|
|
|
|
composer.setSize( window.innerWidth, window.innerHeight );
|
|
|
|
}
|
|
|
|
//
|
|
|
|
function createGUI() {
|
|
|
|
if ( gui ) {
|
|
|
|
gui.destroy();
|
|
|
|
}
|
|
|
|
gui = new GUI( { width: 315 } );
|
|
|
|
const sceneFolder = gui.addFolder( 'Scene' );
|
|
|
|
scene.userData.sceneIndex = currentSceneIndex;
|
|
|
|
sceneFolder.add( scene.userData, 'sceneIndex', { 'Electric Cones': 0, 'Plasma Ball': 1, 'Storm': 2 } ).name( 'Scene' ).onChange( function ( value ) {
|
|
|
|
currentSceneIndex = value;
|
|
|
|
createScene();
|
|
|
|
} );
|
|
|
|
scene.userData.timeRate = 1;
|
|
sceneFolder.add( scene.userData, 'timeRate', scene.userData.canGoBackwardsInTime ? - 1 : 0, 1 ).name( 'Time rate' );
|
|
|
|
sceneFolder.open();
|
|
|
|
const graphicsFolder = gui.addFolder( 'Graphics' );
|
|
|
|
graphicsFolder.add( scene.userData, 'outlineEnabled' ).name( 'Glow enabled' );
|
|
|
|
scene.userData.lightningColorRGB = [
|
|
scene.userData.lightningColor.r * 255,
|
|
scene.userData.lightningColor.g * 255,
|
|
scene.userData.lightningColor.b * 255
|
|
];
|
|
graphicsFolder.addColor( scene.userData, 'lightningColorRGB' ).name( 'Color' ).onChange( function ( value ) {
|
|
|
|
scene.userData.lightningMaterial.color.setRGB( value[ 0 ], value[ 1 ], value[ 2 ] ).multiplyScalar( 1 / 255 );
|
|
|
|
} );
|
|
scene.userData.outlineColorRGB = [
|
|
scene.userData.outlineColor.r * 255,
|
|
scene.userData.outlineColor.g * 255,
|
|
scene.userData.outlineColor.b * 255
|
|
];
|
|
graphicsFolder.addColor( scene.userData, 'outlineColorRGB' ).name( 'Glow color' ).onChange( function ( value ) {
|
|
|
|
scene.userData.outlineColor.setRGB( value[ 0 ], value[ 1 ], value[ 2 ] ).multiplyScalar( 1 / 255 );
|
|
|
|
} );
|
|
|
|
graphicsFolder.open();
|
|
|
|
const rayFolder = gui.addFolder( 'Ray parameters' );
|
|
|
|
rayFolder.add( scene.userData.rayParams, 'straightness', 0, 1 ).name( 'Straightness' );
|
|
rayFolder.add( scene.userData.rayParams, 'roughness', 0, 1 ).name( 'Roughness' );
|
|
rayFolder.add( scene.userData.rayParams, 'radius0', 0.1, 10 ).name( 'Initial radius' );
|
|
rayFolder.add( scene.userData.rayParams, 'radius1', 0.1, 10 ).name( 'Final radius' );
|
|
rayFolder.add( scene.userData.rayParams, 'radius0Factor', 0, 1 ).name( 'Subray initial radius' );
|
|
rayFolder.add( scene.userData.rayParams, 'radius1Factor', 0, 1 ).name( 'Subray final radius' );
|
|
rayFolder.add( scene.userData.rayParams, 'timeScale', 0, 5 ).name( 'Ray time scale' );
|
|
rayFolder.add( scene.userData.rayParams, 'subrayPeriod', 0.1, 10 ).name( 'Subray period (s)' );
|
|
rayFolder.add( scene.userData.rayParams, 'subrayDutyCycle', 0, 1 ).name( 'Subray duty cycle' );
|
|
|
|
if ( scene.userData.recreateRay ) {
|
|
|
|
// Parameters which need to recreate the ray after modification
|
|
|
|
const raySlowFolder = gui.addFolder( 'Ray parameters (slow)' );
|
|
|
|
raySlowFolder.add( scene.userData.rayParams, 'ramification', 0, 15 ).step( 1 ).name( 'Ramification' ).onFinishChange( function () {
|
|
|
|
scene.userData.recreateRay();
|
|
|
|
} );
|
|
|
|
raySlowFolder.add( scene.userData.rayParams, 'maxSubrayRecursion', 0, 5 ).step( 1 ).name( 'Recursion' ).onFinishChange( function () {
|
|
|
|
scene.userData.recreateRay();
|
|
|
|
} );
|
|
|
|
raySlowFolder.add( scene.userData.rayParams, 'recursionProbability', 0, 1 ).name( 'Rec. probability' ).onFinishChange( function () {
|
|
|
|
scene.userData.recreateRay();
|
|
|
|
} );
|
|
|
|
raySlowFolder.open();
|
|
|
|
}
|
|
|
|
rayFolder.open();
|
|
|
|
}
|
|
|
|
//
|
|
|
|
function animate() {
|
|
|
|
requestAnimationFrame( animate );
|
|
|
|
render();
|
|
stats.update();
|
|
|
|
}
|
|
|
|
function render() {
|
|
|
|
currentTime += scene.userData.timeRate * clock.getDelta();
|
|
|
|
if ( currentTime < 0 ) {
|
|
|
|
currentTime = 0;
|
|
|
|
}
|
|
|
|
scene.userData.render( currentTime );
|
|
|
|
}
|
|
|
|
function createOutline( scene, objectsArray, visibleColor ) {
|
|
|
|
const outlinePass = new OutlinePass( new THREE.Vector2( window.innerWidth, window.innerHeight ), scene, scene.userData.camera, objectsArray );
|
|
outlinePass.edgeStrength = 2.5;
|
|
outlinePass.edgeGlow = 0.7;
|
|
outlinePass.edgeThickness = 2.8;
|
|
outlinePass.visibleEdgeColor = visibleColor;
|
|
outlinePass.hiddenEdgeColor.set( 0 );
|
|
composer.addPass( outlinePass );
|
|
|
|
scene.userData.outlineEnabled = true;
|
|
|
|
return outlinePass;
|
|
|
|
}
|
|
|
|
//
|
|
|
|
function createConesScene() {
|
|
|
|
const scene = new THREE.Scene();
|
|
scene.background = new THREE.Color( 0x050505 );
|
|
|
|
scene.userData.canGoBackwardsInTime = true;
|
|
|
|
scene.userData.camera = new THREE.PerspectiveCamera( 27, window.innerWidth / window.innerHeight, 200, 100000 );
|
|
|
|
// Lights
|
|
|
|
scene.userData.lightningColor = new THREE.Color( 0xB0FFFF );
|
|
scene.userData.outlineColor = new THREE.Color( 0x00FFFF );
|
|
|
|
const posLight = new THREE.PointLight( 0x00ffff, 1, 5000, 2 );
|
|
scene.add( posLight );
|
|
|
|
// Ground
|
|
|
|
const ground = new THREE.Mesh( new THREE.PlaneGeometry( 200000, 200000 ), new THREE.MeshPhongMaterial( { color: 0xC0C0C0, shininess: 0 } ) );
|
|
ground.rotation.x = - Math.PI * 0.5;
|
|
scene.add( ground );
|
|
|
|
// Cones
|
|
|
|
const conesDistance = 1000;
|
|
const coneHeight = 200;
|
|
const coneHeightHalf = coneHeight * 0.5;
|
|
|
|
posLight.position.set( 0, ( conesDistance + coneHeight ) * 0.5, 0 );
|
|
posLight.color = scene.userData.outlineColor;
|
|
|
|
scene.userData.camera.position.set( 5 * coneHeight, 4 * coneHeight, 18 * coneHeight );
|
|
|
|
const coneMesh1 = new THREE.Mesh( new THREE.ConeGeometry( coneHeight, coneHeight, 30, 1, false ), new THREE.MeshPhongMaterial( { color: 0xFFFF00, emissive: 0x1F1F00 } ) );
|
|
coneMesh1.rotation.x = Math.PI;
|
|
coneMesh1.position.y = conesDistance + coneHeight;
|
|
scene.add( coneMesh1 );
|
|
|
|
const coneMesh2 = new THREE.Mesh( coneMesh1.geometry.clone(), new THREE.MeshPhongMaterial( { color: 0xFF2020, emissive: 0x1F0202 } ) );
|
|
coneMesh2.position.y = coneHeightHalf;
|
|
scene.add( coneMesh2 );
|
|
|
|
// Lightning strike
|
|
|
|
scene.userData.lightningMaterial = new THREE.MeshBasicMaterial( { color: scene.userData.lightningColor } );
|
|
|
|
scene.userData.rayParams = {
|
|
|
|
sourceOffset: new THREE.Vector3(),
|
|
destOffset: new THREE.Vector3(),
|
|
radius0: 4,
|
|
radius1: 4,
|
|
minRadius: 2.5,
|
|
maxIterations: 7,
|
|
isEternal: true,
|
|
|
|
timeScale: 0.7,
|
|
|
|
propagationTimeFactor: 0.05,
|
|
vanishingTimeFactor: 0.95,
|
|
subrayPeriod: 3.5,
|
|
subrayDutyCycle: 0.6,
|
|
maxSubrayRecursion: 3,
|
|
ramification: 7,
|
|
recursionProbability: 0.6,
|
|
|
|
roughness: 0.85,
|
|
straightness: 0.6
|
|
|
|
};
|
|
|
|
let lightningStrike;
|
|
let lightningStrikeMesh;
|
|
const outlineMeshArray = [];
|
|
|
|
scene.userData.recreateRay = function () {
|
|
|
|
if ( lightningStrikeMesh ) {
|
|
|
|
scene.remove( lightningStrikeMesh );
|
|
|
|
}
|
|
|
|
lightningStrike = new LightningStrike( scene.userData.rayParams );
|
|
lightningStrikeMesh = new THREE.Mesh( lightningStrike, scene.userData.lightningMaterial );
|
|
|
|
outlineMeshArray.length = 0;
|
|
outlineMeshArray.push( lightningStrikeMesh );
|
|
|
|
scene.add( lightningStrikeMesh );
|
|
|
|
};
|
|
|
|
scene.userData.recreateRay();
|
|
|
|
// Compose rendering
|
|
|
|
composer.passes = [];
|
|
composer.addPass( new RenderPass( scene, scene.userData.camera ) );
|
|
createOutline( scene, outlineMeshArray, scene.userData.outlineColor );
|
|
|
|
// Controls
|
|
|
|
const controls = new OrbitControls( scene.userData.camera, renderer.domElement );
|
|
controls.target.y = ( conesDistance + coneHeight ) * 0.5;
|
|
controls.enableDamping = true;
|
|
controls.dampingFactor = 0.05;
|
|
|
|
scene.userData.render = function ( time ) {
|
|
|
|
// Move cones and Update ray position
|
|
coneMesh1.position.set( Math.sin( 0.5 * time ) * conesDistance * 0.6, conesDistance + coneHeight, Math.cos( 0.5 * time ) * conesDistance * 0.6 );
|
|
coneMesh2.position.set( Math.sin( 0.9 * time ) * conesDistance, coneHeightHalf, 0 );
|
|
lightningStrike.rayParameters.sourceOffset.copy( coneMesh1.position );
|
|
lightningStrike.rayParameters.sourceOffset.y -= coneHeightHalf;
|
|
lightningStrike.rayParameters.destOffset.copy( coneMesh2.position );
|
|
lightningStrike.rayParameters.destOffset.y += coneHeightHalf;
|
|
|
|
lightningStrike.update( time );
|
|
|
|
controls.update();
|
|
|
|
// Update point light position to the middle of the ray
|
|
posLight.position.lerpVectors( lightningStrike.rayParameters.sourceOffset, lightningStrike.rayParameters.destOffset, 0.5 );
|
|
|
|
if ( scene.userData.outlineEnabled ) {
|
|
|
|
composer.render();
|
|
|
|
} else {
|
|
|
|
renderer.render( scene, scene.userData.camera );
|
|
|
|
}
|
|
|
|
};
|
|
|
|
return scene;
|
|
|
|
}
|
|
|
|
//
|
|
|
|
function createPlasmaBallScene() {
|
|
|
|
const scene = new THREE.Scene();
|
|
|
|
scene.userData.canGoBackwardsInTime = true;
|
|
|
|
scene.userData.camera = new THREE.PerspectiveCamera( 27, window.innerWidth / window.innerHeight, 100, 50000 );
|
|
|
|
const ballScene = new THREE.Scene();
|
|
ballScene.background = new THREE.Color( 0x454545 );
|
|
|
|
// Lights
|
|
|
|
const ambientLight = new THREE.AmbientLight( 0x444444 );
|
|
ballScene.add( ambientLight );
|
|
scene.add( ambientLight );
|
|
|
|
const light1 = new THREE.DirectionalLight( 0xffffff, 0.5 );
|
|
light1.position.set( 1, 1, 1 );
|
|
ballScene.add( light1 );
|
|
scene.add( light1 );
|
|
|
|
const light2 = new THREE.DirectionalLight( 0xffffff, 1.5 );
|
|
light2.position.set( - 0.5, 1, 0.2 );
|
|
ballScene.add( light2 );
|
|
scene.add( light2 );
|
|
|
|
// Plasma ball
|
|
|
|
scene.userData.lightningColor = new THREE.Color( 0xFFB0FF );
|
|
scene.userData.outlineColor = new THREE.Color( 0xFF00FF );
|
|
|
|
scene.userData.lightningMaterial = new THREE.MeshBasicMaterial( { color: scene.userData.lightningColor, side: THREE.DoubleSide } );
|
|
|
|
const r = 'textures/cube/Bridge2/';
|
|
const urls = [ r + 'posx.jpg', r + 'negx.jpg',
|
|
r + 'posy.jpg', r + 'negy.jpg',
|
|
r + 'posz.jpg', r + 'negz.jpg' ];
|
|
|
|
const textureCube = new THREE.CubeTextureLoader().load( urls );
|
|
textureCube.mapping = THREE.CubeReflectionMapping;
|
|
textureCube.encoding = THREE.sRGBEncoding;
|
|
|
|
const sphereMaterial = new THREE.MeshPhysicalMaterial( {
|
|
transparent: true,
|
|
transmission: .96,
|
|
depthWrite: false,
|
|
color: 'white',
|
|
metalness: 0,
|
|
roughness: 0,
|
|
envMap: textureCube
|
|
} );
|
|
|
|
const sphereHeight = 300;
|
|
const sphereRadius = 200;
|
|
|
|
scene.userData.camera.position.set( 5 * sphereRadius, 2 * sphereHeight, 6 * sphereRadius );
|
|
|
|
const sphereMesh = new THREE.Mesh( new THREE.SphereGeometry( sphereRadius, 80, 40 ), sphereMaterial );
|
|
sphereMesh.position.set( 0, sphereHeight, 0 );
|
|
ballScene.add( sphereMesh );
|
|
|
|
const sphere = new THREE.Sphere( sphereMesh.position, sphereRadius );
|
|
|
|
const spherePlasma = new THREE.Mesh( new THREE.SphereGeometry( sphereRadius * 0.05, 24, 12 ), scene.userData.lightningMaterial );
|
|
spherePlasma.position.copy( sphereMesh.position );
|
|
spherePlasma.scale.y = 0.6;
|
|
scene.add( spherePlasma );
|
|
|
|
const post = new THREE.Mesh(
|
|
new THREE.CylinderGeometry( sphereRadius * 0.06, sphereRadius * 0.06, sphereHeight, 6, 1, true ),
|
|
new THREE.MeshLambertMaterial( { color: 0x020202 } )
|
|
);
|
|
post.position.y = sphereHeight * 0.5 - sphereRadius * 0.05 * 1.2;
|
|
scene.add( post );
|
|
|
|
const box = new THREE.Mesh( new THREE.BoxGeometry( sphereHeight * 0.5, sphereHeight * 0.1, sphereHeight * 0.5 ), post.material );
|
|
box.position.y = sphereHeight * 0.05 * 0.5;
|
|
scene.add( box );
|
|
|
|
const rayDirection = new THREE.Vector3();
|
|
let rayLength = 0;
|
|
const vec1 = new THREE.Vector3();
|
|
const vec2 = new THREE.Vector3();
|
|
|
|
scene.userData.rayParams = {
|
|
|
|
sourceOffset: sphereMesh.position,
|
|
destOffset: new THREE.Vector3( sphereRadius, 0, 0 ).add( sphereMesh.position ),
|
|
radius0: 4,
|
|
radius1: 4,
|
|
radius0Factor: 0.82,
|
|
minRadius: 2.5,
|
|
maxIterations: 6,
|
|
isEternal: true,
|
|
|
|
timeScale: 0.6,
|
|
propagationTimeFactor: 0.15,
|
|
vanishingTimeFactor: 0.87,
|
|
subrayPeriod: 0.8,
|
|
ramification: 5,
|
|
recursionProbability: 0.8,
|
|
|
|
roughness: 0.85,
|
|
straightness: 0.7,
|
|
|
|
onSubrayCreation: function ( segment, parentSubray, childSubray, lightningStrike ) {
|
|
|
|
lightningStrike.subrayConePosition( segment, parentSubray, childSubray, 0.6, 0.9, 0.7 );
|
|
|
|
// THREE.Sphere projection
|
|
|
|
vec1.subVectors( childSubray.pos1, lightningStrike.rayParameters.sourceOffset );
|
|
vec2.set( 0, 0, 0 );
|
|
|
|
if ( lightningStrike.randomGenerator.random() < 0.7 ) {
|
|
|
|
vec2.copy( rayDirection ).multiplyScalar( rayLength * 1.0865 );
|
|
|
|
}
|
|
|
|
vec1.add( vec2 ).setLength( rayLength );
|
|
childSubray.pos1.addVectors( vec1, lightningStrike.rayParameters.sourceOffset );
|
|
|
|
}
|
|
|
|
};
|
|
|
|
let lightningStrike;
|
|
let lightningStrikeMesh;
|
|
const outlineMeshArray = [];
|
|
|
|
scene.userData.recreateRay = function () {
|
|
|
|
if ( lightningStrikeMesh ) {
|
|
|
|
scene.remove( lightningStrikeMesh );
|
|
|
|
}
|
|
|
|
lightningStrike = new LightningStrike( scene.userData.rayParams );
|
|
lightningStrikeMesh = new THREE.Mesh( lightningStrike, scene.userData.lightningMaterial );
|
|
|
|
outlineMeshArray.length = 0;
|
|
outlineMeshArray.push( lightningStrikeMesh );
|
|
outlineMeshArray.push( spherePlasma );
|
|
|
|
scene.add( lightningStrikeMesh );
|
|
|
|
};
|
|
|
|
scene.userData.recreateRay();
|
|
|
|
// Compose rendering
|
|
|
|
composer.passes = [];
|
|
|
|
composer.addPass( new RenderPass( ballScene, scene.userData.camera ) );
|
|
|
|
const rayPass = new RenderPass( scene, scene.userData.camera );
|
|
rayPass.clear = false;
|
|
composer.addPass( rayPass );
|
|
|
|
const outlinePass = createOutline( scene, outlineMeshArray, scene.userData.outlineColor );
|
|
|
|
scene.userData.render = function ( time ) {
|
|
|
|
rayDirection.subVectors( lightningStrike.rayParameters.destOffset, lightningStrike.rayParameters.sourceOffset );
|
|
rayLength = rayDirection.length();
|
|
rayDirection.normalize();
|
|
|
|
lightningStrike.update( time );
|
|
|
|
controls.update();
|
|
|
|
outlinePass.enabled = scene.userData.outlineEnabled;
|
|
|
|
composer.render();
|
|
|
|
};
|
|
|
|
// Controls
|
|
|
|
const controls = new OrbitControls( scene.userData.camera, renderer.domElement );
|
|
controls.target.copy( sphereMesh.position );
|
|
controls.enableDamping = true;
|
|
controls.dampingFactor = 0.05;
|
|
|
|
// THREE.Sphere mouse raycasting
|
|
|
|
container.style.touchAction = 'none';
|
|
container.addEventListener( 'pointermove', onPointerMove );
|
|
|
|
function onPointerMove( event ) {
|
|
|
|
if ( event.isPrimary === false ) return;
|
|
|
|
mouse.x = ( event.clientX / window.innerWidth ) * 2 - 1;
|
|
mouse.y = - ( event.clientY / window.innerHeight ) * 2 + 1;
|
|
|
|
checkIntersection();
|
|
|
|
}
|
|
|
|
const intersection = new THREE.Vector3();
|
|
|
|
function checkIntersection() {
|
|
|
|
raycaster.setFromCamera( mouse, scene.userData.camera );
|
|
|
|
const result = raycaster.ray.intersectSphere( sphere, intersection );
|
|
|
|
if ( result !== null ) {
|
|
|
|
lightningStrike.rayParameters.destOffset.copy( intersection );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return scene;
|
|
|
|
}
|
|
|
|
//
|
|
|
|
function createStormScene() {
|
|
|
|
const scene = new THREE.Scene();
|
|
scene.background = new THREE.Color( 0x050505 );
|
|
|
|
scene.userData.canGoBackwardsInTime = false;
|
|
|
|
scene.userData.camera = new THREE.PerspectiveCamera( 27, window.innerWidth / window.innerHeight, 20, 10000 );
|
|
|
|
// Lights
|
|
|
|
scene.add( new THREE.AmbientLight( 0x444444 ) );
|
|
|
|
const light1 = new THREE.DirectionalLight( 0xffffff, 0.5 );
|
|
light1.position.set( 1, 1, 1 );
|
|
scene.add( light1 );
|
|
|
|
const posLight = new THREE.PointLight( 0x00ffff );
|
|
posLight.position.set( 0, 100, 0 );
|
|
scene.add( posLight );
|
|
|
|
// Ground
|
|
|
|
const GROUND_SIZE = 1000;
|
|
|
|
scene.userData.camera.position.set( 0, 0.2, 1.6 ).multiplyScalar( GROUND_SIZE * 0.5 );
|
|
|
|
const ground = new THREE.Mesh( new THREE.PlaneGeometry( GROUND_SIZE, GROUND_SIZE ), new THREE.MeshLambertMaterial( { color: 0x072302 } ) );
|
|
ground.rotation.x = - Math.PI * 0.5;
|
|
scene.add( ground );
|
|
|
|
// Storm
|
|
|
|
scene.userData.lightningColor = new THREE.Color( 0xB0FFFF );
|
|
scene.userData.outlineColor = new THREE.Color( 0x00FFFF );
|
|
|
|
scene.userData.lightningMaterial = new THREE.MeshBasicMaterial( { color: scene.userData.lightningColor } );
|
|
|
|
const rayDirection = new THREE.Vector3( 0, - 1, 0 );
|
|
let rayLength = 0;
|
|
const vec1 = new THREE.Vector3();
|
|
const vec2 = new THREE.Vector3();
|
|
|
|
scene.userData.rayParams = {
|
|
|
|
radius0: 1,
|
|
radius1: 0.5,
|
|
minRadius: 0.3,
|
|
maxIterations: 7,
|
|
|
|
timeScale: 0.15,
|
|
propagationTimeFactor: 0.2,
|
|
vanishingTimeFactor: 0.9,
|
|
subrayPeriod: 4,
|
|
subrayDutyCycle: 0.6,
|
|
|
|
maxSubrayRecursion: 3,
|
|
ramification: 3,
|
|
recursionProbability: 0.4,
|
|
|
|
roughness: 0.85,
|
|
straightness: 0.65,
|
|
|
|
onSubrayCreation: function ( segment, parentSubray, childSubray, lightningStrike ) {
|
|
|
|
lightningStrike.subrayConePosition( segment, parentSubray, childSubray, 0.6, 0.6, 0.5 );
|
|
|
|
// Plane projection
|
|
|
|
rayLength = lightningStrike.rayParameters.sourceOffset.y;
|
|
vec1.subVectors( childSubray.pos1, lightningStrike.rayParameters.sourceOffset );
|
|
const proj = rayDirection.dot( vec1 );
|
|
vec2.copy( rayDirection ).multiplyScalar( proj );
|
|
vec1.sub( vec2 );
|
|
const scale = proj / rayLength > 0.5 ? rayLength / proj : 1;
|
|
vec2.multiplyScalar( scale );
|
|
vec1.add( vec2 );
|
|
childSubray.pos1.addVectors( vec1, lightningStrike.rayParameters.sourceOffset );
|
|
|
|
}
|
|
|
|
};
|
|
|
|
// Black star mark
|
|
const starVertices = [];
|
|
const prevPoint = new THREE.Vector3( 0, 0, 1 );
|
|
const currPoint = new THREE.Vector3();
|
|
for ( let i = 1; i <= 16; i ++ ) {
|
|
|
|
currPoint.set( Math.sin( 2 * Math.PI * i / 16 ), 0, Math.cos( 2 * Math.PI * i / 16 ) );
|
|
|
|
if ( i % 2 === 1 ) {
|
|
|
|
currPoint.multiplyScalar( 0.3 );
|
|
|
|
}
|
|
|
|
starVertices.push( 0, 0, 0 );
|
|
starVertices.push( prevPoint.x, prevPoint.y, prevPoint.z );
|
|
starVertices.push( currPoint.x, currPoint.y, currPoint.z );
|
|
|
|
prevPoint.copy( currPoint );
|
|
|
|
}
|
|
|
|
const starGeometry = new THREE.BufferGeometry();
|
|
starGeometry.setAttribute( 'position', new THREE.Float32BufferAttribute( starVertices, 3 ) );
|
|
const starMesh = new THREE.Mesh( starGeometry, new THREE.MeshBasicMaterial( { color: 0x020900 } ) );
|
|
starMesh.scale.multiplyScalar( 6 );
|
|
|
|
//
|
|
|
|
const storm = new LightningStorm( {
|
|
|
|
size: GROUND_SIZE,
|
|
minHeight: 90,
|
|
maxHeight: 200,
|
|
maxSlope: 0.6,
|
|
maxLightnings: 8,
|
|
|
|
lightningParameters: scene.userData.rayParams,
|
|
|
|
lightningMaterial: scene.userData.lightningMaterial,
|
|
|
|
onLightningDown: function ( lightning ) {
|
|
|
|
// Add black star mark at ray strike
|
|
const star1 = starMesh.clone();
|
|
star1.position.copy( lightning.rayParameters.destOffset );
|
|
star1.position.y = 0.05;
|
|
star1.rotation.y = 2 * Math.PI * Math.random();
|
|
scene.add( star1 );
|
|
|
|
}
|
|
|
|
} );
|
|
|
|
scene.add( storm );
|
|
|
|
// Compose rendering
|
|
|
|
composer.passes = [];
|
|
composer.addPass( new RenderPass( scene, scene.userData.camera ) );
|
|
createOutline( scene, storm.lightningsMeshes, scene.userData.outlineColor );
|
|
|
|
// Controls
|
|
|
|
const controls = new OrbitControls( scene.userData.camera, renderer.domElement );
|
|
controls.target.y = GROUND_SIZE * 0.05;
|
|
controls.enableDamping = true;
|
|
controls.dampingFactor = 0.05;
|
|
|
|
scene.userData.render = function ( time ) {
|
|
|
|
storm.update( time );
|
|
|
|
controls.update();
|
|
|
|
if ( scene.userData.outlineEnabled ) {
|
|
|
|
composer.render();
|
|
|
|
} else {
|
|
|
|
renderer.render( scene, scene.userData.camera );
|
|
|
|
}
|
|
|
|
};
|
|
|
|
return scene;
|
|
|
|
}
|
|
|
|
</script>
|
|
|
|
</body>
|
|
</html>
|
|
|