【幻妙音符——HTML 实现（效果+代码，Web前端面试你必须要知道的那些知识

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024c （备注前端）

正文

• • 效果

• 代码

• 说明

效果

---

鉴于篇幅以及图片大小，效果仅展示一部分，具体特效欢迎大家体验~

代码

---

这是HTML代码，主要是引用的JS部分代码。

index.html

JS部分代码示例：

index.js

const COLORS = {

red: 0xf54843,

green: 0x43f565,

yellow: 0xeff543,

};

const SCENE_CONFIG = {

pathRadius: 4,

pathAnimationDuration: 20,

cameraSpeed: 14.079549454417457,

};

const NEXT_PATH_MATRIX = new THREE.Matrix4().multiplyMatrices(

new THREE.Matrix4().makeTranslation(0, 0, -8),

new THREE.Matrix4().makeScale(-1, -1, 1)

);

let root;

let tubes = [];

let cameraTween;

window.onload = function() {

root = new THREERoot({

createCameraControls: false,

antialias: true, //(window.devicePixelRatio === 1),

fov: 80,

zNear: 0.001,

zFar: 2000,

});

root.renderer.setClearColor(new THREE.Color().setHSL(0, 0, 0.05));

root.camera.position.set(0, 0.05, 1);

createTubes();

beginTubesSequence();

};

// METHODS

function createTubes() {

const matrix = new THREE.Matrix4();

matrix.makeRotationZ(Math.PI * 0.00);

tubes[0] = createPathMesh(matrix);

matrix.makeRotationZ(Math.PI * 0.66);

tubes[1] = createPathMesh(matrix);

matrix.makeRotationZ(Math.PI * 1.32);

tubes[2] = createPathMesh(matrix);

}

function beginTubesSequence() {

// BLOOM

const strength = 1.25; // 0 - x

const radius = 1.0; // 0 - 1

const threshold = 0.5; // 0 - 1

const bloomPass = new THREE.UnrealBloomPass(

new THREE.Vector2(window.innerWidth, window.innerHeight),

strength,

radius,

threshold

);

const copyPass = new THREE.ShaderPass(THREE.CopyShader);

root.initPostProcessing([

bloomPass,

copyPass

]);

// LIGHT

let light;

light = new THREE.DirectionalLight(COLORS.red, 1);

light.position.set(1, 0, 0);

root.add(light);

light = new THREE.DirectionalLight(COLORS.green, 1);

light.position.set(-1, 0, 0);

root.add(light);

light = new THREE.DirectionalLight(COLORS.red, 1);

light.position.set(0, 0, 1);

root.add(light);

let cameraPanRange = 1.0, cameraYawRange = cameraPanRange * 1.125;

window.addEventListener(‘mousemove’, (e) => {

const nx = e.clientX / window.innerWidth * 2 - 1;

const ny = -e.clientY / window.innerHeight * 2 + 1;

const ry = -THREE.Math.mapLinear(nx, -1, 1, cameraPanRange * -0.5, cameraPanRange * 0.5);

const rx = THREE.Math.mapLinear(ny, -1, 1, cameraYawRange * -0.5, cameraYawRange * 0.5);

TweenMax.to(root.camera.rotation, 1, {

x: rx,

y: ry,

ease: Power2.easeOut,

});

});

const tweenCamera = () => {

cameraTween = TweenMax.to(root.camera.position, SCENE_CONFIG.cameraSpeed, {

z: -=${SCENE_CONFIG.pathRadius * 2},

ease: Power0.easeIn,

onComplete: tweenCamera

});

};

tweenCamera();

cameraTween.timeScale(0);

const proxy = {

rx: 0,

ry: 0,

rz: 0,

cz: 0,

};

const camTL = new TimelineMax();

camTL.to(proxy, 4, {rz: 1, cz: 1, ease: Power2.easeIn, onUpdate: () => {

cameraTween.timeScale(proxy.cz);

}}, 0);

root.addUpdateCallback(() => {

root.scene.rotation.z -= proxy.rz * 0.003;

});

tubes.forEach((tube) => {

root.add(tube);

advanceTube(tube);

});

}

function advanceTube(tube) {

const tl = new TimelineMax();

const firstCompleteTime = tube.geometry.firstCompleteTime * tube.__config.duration;

tl.add(tube.animate(tube.__config.duration, {ease: Power0.easeInOut}));

tl.add(() => {

const transformMatrix = new THREE.Matrix4().multiplyMatrices(

tube.__pathMatrix,

NEXT_PATH_MATRIX

);

const nextTube = createPathMesh(transformMatrix, {

tubeCount: tube.__config.tubeCount,

tubeArcLength: tube.__config.tubeArcLength,

tubeStagger: tube.__config.tubeStagger

});

root.add(nextTube);

advanceTube(nextTube);

}, firstCompleteTime);

tl.add(() => {

root.remove(tube);

tube.geometry.dispose();

tube.material.dispose();

});

}

function createPath() {

let length = 16;

let path = [];

let point = new THREE.Vector3();

for (let i = 0; i < length; i++) {

let angle = i / (length - 1) * Math.PI - Math.PI * 1.5;

let radius = SCENE_CONFIG.pathRadius;

let scaleX = THREE.Math.mapLinear(i, 0, length - 1, 0.75, 0.25) * THREE.Math.randFloat(0.6, 1.0);

point.x = Math.cos(angle) * radius * scaleX;

point.z = Math.sin(angle) * radius - radius;

point.y = (i === 0 || i === length - 1) ? 0 : THREE.Math.randFloatSpread(2) * (i / length);

// point.y = 0;

let twistOffset = (i === 0 || i === length - 1) ? 0 : THREE.Math.randFloatSpread(2);

// let twistOffset = 0;

path.push(new THREE.Vector4(point.x, point.y, point.z, twistOffset));

}

return path;

}

function createPathMesh(matrix, cfg) {

const config = Object.assign(

{},

cfg,

{

tubeSegments: 128,

// tubeCount: THREE.Math.randInt(32, 48),

// tubeArcLength: THREE.Math.randFloat(0.15, 0.3),

// tubeStagger: THREE.Math.randFloat(0.0002, 0.002),

tubeCount: 32,

tubeArcLength: 0.25,

tubeStagger: 0.001,

tubeRadius: THREE.Math.randFloat(0.005, 0.01),

twistDistance: THREE.Math.randFloat(0.1, 1.5),

twistAngle: Math.PI * THREE.Math.randFloat(2, 16),

duration: SCENE_CONFIG.pathAnimationDuration,

path: createPath()

}

);

const mesh = new Tubes(config);

mesh.applyMatrix(matrix);

mesh.__pathMatrix = matrix.clone();

mesh.__config = config;

return mesh;

}

// CLASSES

function Tubes(config) {

const geometry = new TubesGeometry(config);

const material = new THREE.BAS.StandardAnimationMaterial({

shading: THREE.FlatShading,

defines: {

ROBUST: false,

TUBE_LENGTH_SEGMENTS: config.tubeSegments.toFixed(1),

PATH_LENGTH: config.path.length,

PATH_MAX: (config.path.length - 1).toFixed(1)

},

uniforms: {

thickness: {value: config.tubeRadius},

uTwist: {

value: new THREE.Vector2(

config.twistDistance,

config.twistAngle

)

},

time: {value: 0.0},

uPath: {value: config.path}

},

uniformValues: {

diffuse: new THREE.Color(COLORS.yellow),

roughness: .75,

metalness: .0

},

vertexParameters: [

THREE.BAS.ShaderChunk[‘catmull_rom_spline’],

`

attribute vec2 aAngle;

attribute float aTwistOffset;

uniform float thickness;

uniform float time;

uniform vec2 uTwist;

uniform vec4 uPath[PATH_LENGTH];

varying float vProgress;

#ifdef ROBUST

const float MAX_NUMBER = 1.79769313e+32;

#endif

vec3 sample(float t) {

float pathProgress = t * PATH_MAX;

最后

❤️ 谢谢支持，喜欢的话别忘了 关注、点赞哦。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注前端）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
c2 aAngle;

attribute float aTwistOffset;

uniform float thickness;

uniform float time;

uniform vec2 uTwist;

uniform vec4 uPath[PATH_LENGTH];

varying float vProgress;

#ifdef ROBUST

const float MAX_NUMBER = 1.79769313e+32;

#endif

vec3 sample(float t) {

float pathProgress = t * PATH_MAX;

最后

❤️ 谢谢支持，喜欢的话别忘了 关注、点赞哦。

[外链图片转存中…(img-tLxnzALZ-1713434346361)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注前端）
[外链图片转存中…(img-43rCwndy-1713434346362)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！