【时光隧道——使用Html、JavaScript等实现（附源代码）】

return force;

},

hook: function(velocity, anchor, rest_length, k) {

var force = velocity.clone().sub(anchor);

var distance = force.length() - rest_length;

force.normalize();

force.multiplyScalar(-1 * k * distance);

return force;

}

};

module.exports = exports;

},{}],5:[function(require,module,exports){

var Util = require(‘./util’);

var exports = function(){

var HemiLight = function() {

this.rad1 = Util.getRadian(60);

this.rad2 = Util.getRadian(30);

this.range = 1000;

this.hex1 = 0xffffff;

this.hex2 = 0x333333;

this.intensity = 1;

this.obj;

};

HemiLight.prototype = {

init: function(hex1, hex2) {

if (hex1) this.hex1 = hex1;

if (hex2) this.hex2 = hex2;

this.obj = new THREE.HemisphereLight(this.hex1, this.hex2, this.intensity);

this.setPosition();

},

setPosition: function() {

var points = Util.getSpherical(this.rad1, this.rad2, this.range);

this.obj.position.set(points[0], points[1], points[2]);

}

};

return HemiLight;

};

module.exports = exports();

},{“./util”:8}],6:[function(require,module,exports){

var Util = require(‘./Util’);

var debounce = require(‘./debounce’);

var Camera = require(‘./camera’);

var HemiLight = require(‘./hemiLight’);

var Mover = require(‘./mover’);

var body_width = document.body.clientWidth;

var body_height = document.body.clientHeight;

var last_time_activate = Date.now();

var canvas = null;

var renderer = null;

var scene = null;

var camera = null;

var light = null;

var movers_num = 10000;

var movers = [];

var points_geometry = null;

var points_material = null;

var points = null;

var textplate_geometry = null;

var textplate_material = null;

var textplate = null;

var antigravity = new THREE.Vector3(0, 30, 0);

var initThree = function() {

canvas = document.getElementById(‘canvas’);

renderer = new THREE.WebGLRenderer({

antialias: true,

alpha: true

});

if (!renderer) {

alert(‘Three.js failed to load’);

}

renderer.setSize(body_width, body_height);

canvas.appendChild(renderer.domElement);

renderer.setClearColor(0x111111, 1.0);

scene = new THREE.Scene();

scene.fog = new THREE.Fog(0x000000, 800, 1600);

camera = new Camera();

camera.init(body_width, body_height);

light = new HemiLight();

light.init(0xffff99, 0x99ffcc);

scene.add(light.obj);

};

var init = function() {

initThree();

buildPoints();

renderloop();

debounce(window, ‘resize’, function(event){

resizeRenderer();

});

};

var activateMover = function () {

var count = 0;

for (var i = 0; i < movers.length; i++) {

var mover = movers[i];

if (mover.is_active) continue;

mover.activate();

mover.velocity.y = -300;

count++;

if (count >= 50) break;

}

};

var buildPoints = function() {

var tx_canvas = document.createElement(‘canvas’);

var tx_ctx = tx_canvas.getContext(‘2d’);

var tx_grad = null;

var texture = null;

tx_canvas.width = 200;

tx_canvas.height = 200;

tx_grad = tx_ctx.createRadialGradient(100, 100, 20, 100, 100, 100);

tx_grad.addColorStop(0.2, ‘rgba(255, 255, 255, 1)’);

tx_grad.addColorStop(0.5, ‘rgba(255, 255, 255, 0.3)’);

tx_grad.addColorStop(1.0, ‘rgba(255, 255, 255, 0)’);

tx_ctx.fillStyle = tx_grad;

tx_ctx.arc(100, 100, 100, 0, Math.PI / 180, true);

tx_ctx.fill();

texture = new THREE.Texture(tx_canvas);

texture.minFilter = THREE.NearestFilter;

texture.needsUpdate = true;

points_geometry = new THREE.Geometry();

points_material = new THREE.PointsMaterial({

color: 0xffff50,

size: 30,

transparent: true,

opacity: 0.8,

map: texture,

depthTest: false,

blending: THREE.AdditiveBlending,

});

points_geometry2 = new THREE.Geometry();

points_material2 = new THREE.PointsMaterial({

color: 0x99ffcc,

size: 30,

transparent: true,

opacity: 0.8,

map: texture,

depthTest: false,

blending: THREE.AdditiveBlending,

});

for (var i = 0; i < movers_num; i++) {

var mover = new Mover();

var range = Math.log(Util.getRandomInt(2, 256)) / Math.log(256) * 250 + 50;

var rad = Util.getRadian(Util.getRandomInt(0, 180) * 2);

var x = Math.cos(rad) * range;

var z = Math.sin(rad) * range;

mover.init(new THREE.Vector3(x, 1000, z));

mover.mass = Util.getRandomInt(200, 500) / 100;

movers.push(mover);

if (i % 2 === 0) {

points_geometry.vertices.push(mover.position);

} else {

points_geometry2.vertices.push(mover.position);

}

}

points = new THREE.Points(points_geometry, points_material);

points2 = new THREE.Points(points_geometry2, points_material2);

scene.add(points);

scene.add(points2);

};

var updatePoints = function() {

var points_vertices = [];

var points_vertices2 = [];

for (var i = 0; i < movers.length; i++) {

var mover = movers[i];

if (mover.is_active) {

mover.applyForce(antigravity);

mover.updateVelocity();

mover.updatePosition();

if (mover.position.y > 1000) {

var range = Math.log(Util.getRandomInt(2, 256)) / Math.log(256) * 250 + 50;

var rad = Util.getRadian(Util.getRandomInt(0, 180) * 2);

var x = Math.cos(rad) * range;

var z = Math.sin(rad) * range;

mover.init(new THREE.Vector3(x, -300, z));

mover.mass = Util.getRandomInt(200, 500) / 100;

}

}

if (i % 2 === 0) {

points_vertices.push(mover.position);

} else {

points_vertices2.push(mover.position);

}

}

points.geometry.vertices = points_vertices;

points.geometry.verticesNeedUpdate = true;

points2.geometry.vertices = points_vertices2;

points2.geometry.verticesNeedUpdate = true;

};

var rotateCamera = function() {

camera.rad2 += Util.getRadian(0.1);

camera.reset();

};

var raycast = function(vector) {

vector.x = (vector.x / window.innerWidth) * 2 - 1;

vector.y = - (vector.y / window.innerHeight) * 2 + 1;

raycaster.setFromCamera(vector, camera.obj);

intersects = raycaster.intersectObjects(scene.children);

};

var render = function() {

renderer.clear();

updatePoints();

rotateCamera();

renderer.render(scene, camera.obj);

};

var renderloop = function() {

var now = Date.now();

requestAnimationFrame(renderloop);

render();

if (now - last_time_activate > 10) {

activateMover();

last_time_activate = Date.now();

}

};

var resizeRenderer = function() {

body_width = document.body.clientWidth;

body_height = document.body.clientHeight;

renderer.setSize(body_width, body_height);

camera.resize(body_width, body_height);

};

init();

},{“./Util”:1,“./camera”:2,“./debounce”:3,“./hemiLight”:5,“./mover”:7}],7:[function(require,module,exports){

var Util = require(‘./util’);

var Force = require(‘./force’);

var exports = function(){

var Mover = function() {

this.position = new THREE.Vector3();

this.velocity = new THREE.Vector3();

this.acceleration = new THREE.Vector3();

this.anchor = new THREE.Vector3();

this.mass = 1;

this.r = 0;

this.g = 0;

this.b = 0;

this.a = 1;

this.time = 0;

this.is_active = false;

};

Mover.prototype = {

init: function(vector) {

this.position = vector.clone();

this.velocity = vector.clone();

this.anchor = vector.clone();

this.acceleration.set(0, 0, 0);

this.a = 1;

this.time = 0;

},

updatePosition: function() {

this.position.copy(this.velocity);

},

updateVelocity: function() {

this.acceleration.divideScalar(this.mass);

this.velocity.add(this.acceleration);

// if (this.velocity.distanceTo(this.position) >= 1) {

// this.direct(this.velocity);

// }

},

applyForce: function(vector) {

this.acceleration.add(vector);

},

applyFriction: function() {

var friction = Force.friction(this.acceleration, 0.1);

this.applyForce(friction);

},

applyDragForce: function(value) {

var drag = Force.drag(this.acceleration, value);

this.applyForce(drag);

},

hook: function(rest_length, k) {

var force = Force.hook(this.velocity, this.anchor, rest_length, k);

this.applyForce(force);

},

activate: function () {

this.is_active = true;

},

inactivate: function () {

this.is_active = false;

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-MkoFLzvk-1715057208142)]

[外链图片转存中…(img-APwd9OCn-1715057208143)]

[外链图片转存中…(img-yJzONNeL-1715057208143)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！