three+webgl实现2025新年快乐文字灵光动画效果代码

代码语言:html

所属分类:动画

代码描述:three+webgl实现2025新年快乐文字灵光动画效果代码

代码标签: three webgl 2025 新年 快乐 文字 灵光 动画

下面为部分代码预览,完整代码请点击下载或在bfwstudio webide中打开

<!DOCTYPE html>
<html lang="en" >

<head>
  <meta charset="UTF-8">

  
  
<style>
body{
  overflow: hidden;
  margin: 0;
}
</style>


  
  
</head>

<body translate="no">
      
    <script type="importmap">
  {
    "imports": {
      "three": "//repo.bfw.wiki/bfwrepo/js/module/three/build/171/three.module.js",
    
      "three/addons/": "//repo.bfw.wiki/bfwrepo/js/module/three/examples/171/jsm/"
    }
  }
</script>

<script>
  let rotations = `
    // https://forum.gamemaker.io/index.php?threads/solved-3d-rotations-with-a-shader-matrix-or-a-matrix-glsl-es.61064/
      mat4 rx(float a) {
        return mat4( 1.0, 0.0, 0.0, 0.0,
                     0.0,cos(a),sin(a), 0.0,
                     0.0,-sin(a),cos(a), 0.0,
                     0.0, 0.0, 0.0, 1.0);
      }

      mat4 ry(float a){
        return mat4( cos(a),0.0, -sin(a), 0.0,
                     0.0, 1.0, 0.0, 0.0,
                     sin(a), 0.0, cos(a), 0.0,
                     0.0,0.0,0.0,1.0);
      }
               
      mat4 rz(float a){
        return mat4( cos(a), sin(a), 0.0, 0.0,
                     -sin(a), cos(a), 0.0, 0.0,
                     0.0        , 0.0       ,1.0 ,0.0,
                     0.0        , 0.0       ,0.0 ,1.0);
      }
      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      
      mat4 rotationXYZ(vec3 angles){
        return rz(angles.z) * ry(angles.y) * rx(angles.x);
      }
  `;
</script>
  
      <script type="module">
import * as THREE from "three";
import { OrbitControls } from "three/addons/controls/OrbitControls.js";

import { EffectComposer } from 'three/addons/postprocessing/EffectComposer.js';
import { RenderPass } from 'three/addons/postprocessing/RenderPass.js';
import { ShaderPass } from 'three/addons/postprocessing/ShaderPass.js';
import { VignetteShader } from 'three/addons/shaders/VignetteShader.js';
import { GammaCorrectionShader } from 'three/addons/shaders/GammaCorrectionShader.js';

console.clear();

window.addEventListener("dblclick", () => {
  if(!document.fullscreenElement){
    document.documentElement.requestFullscreen();
  }else{
    document.exitFullscreen();
  }
});

// load fonts
await (async function () {
  async function loadFont(fontface) {
    await fontface.load();
    document.fonts.add(fontface);
  }
  let fonts = [
    new FontFace(
      "Limelight",
      "url(https://fonts.gstatic.com/s/limelight/v19/XLYkIZL7aopJVbZJHDuoNOlH.woff2) format('woff2')"
    ),
    new FontFace(
      "BerkshireSwash",
      "url(https://fonts.gstatic.com/s/berkshireswash/v20/ptRRTi-cavZOGqCvnNJDl5m5XmN_qs4z.woff2) format('woff2')"
    )
  ];
  for (let font in fonts) {
    await loadFont(fonts[font]);
  }
})();

class Postprocessing extends EffectComposer{
  constructor(){
    super(renderer, new THREE.WebGLRenderTarget(innerWidth, innerHeight, {samples: 4}));
    
    let renderPass = new RenderPass(scene, camera);
    let effectVignette = new ShaderPass(VignetteShader);
        effectVignette.uniforms[ 'offset' ].value = 0.2;
	      effectVignette.uniforms[ 'darkness' ].value = 10;
    let gammaCorrection = new ShaderPass( GammaCorrectionShader );
    
    //console.log(effectVignette.material);
    effectVignette.material.onBeforeCompile = shader => {
      shader.uniforms.time = gu.time;
      shader.uniforms.aspect = gu.aspect;
      shader.uniforms.texWriting = {
        value: (() => {
          let c = document.createElement("canvas");
          c.width = 2048;
          c.height = 512;
          let ctx = c.getContext("2d");
          let u = val => val * c.height * 0.01;
          
          ctx.fillStyle = `rgba(255, 255, 255, 0.5)`;
          ctx.strokeStyle = `rgba(255, 255, 255, 1)`;
          ctx.lineWidth = u(2);
          ctx.font = `${u(45)}px BerkshireSwash`;
          ctx.textAlign = "center";
          ctx.textBaseline = "middle";
          
          //ctx.strokeRect(0, 0, c.width, c.height);
          ctx.strokeText("Happy New Year!", c.width * 0.5, c.height * 0.5);
          ctx.fillText("Happy New Year!", c.width * 0.5, c.height * 0.5);
          
          let tex = new THREE.CanvasTexture(c);
          tex.colorSpace = "srgb";
          
          return tex;
        })()
      }
      
      shader.fragmentShader = `
        uniform float time;
        uniform float aspect;
        uniform sampler2D texWriting;
        
        vec2 N22(vec2 p){
          vec3 a = fract(p.xyx * vec3(123.45, 234.56, 345.67));
          a += dot(a, a+45.69);
          return fract(vec2(a.x * a.y, a.y * a.z));
        }
        ${shader.fragmentShader}
      `.replace(
        `gl_FragColor = vec4( mix( texel.rgb, vec3( 1.0 - darkness ), dot( uv, uv ) ), texel.a );`,
        `gl_FragColor = vec4( mix( texel.rgb, vec3( 1.0 - darkness ), dot( uv, uv ) ), texel.a );
        
        vec2 texUV = (vUv - 0.5) * vec2(aspect, 4.) + 0.5;
        texUV.y += 1.7;

        float col = texture(texWriting, texUV).a;
        
        gl_FragColor.rgb = mix(gl_FragColor.rgb, vec3(0.9875, 1, 1) * 0.9, col);
        
        `
      );
      console.log(shader.fragmentShader);
    }
    
    this.addPass(renderPass);
    this.addPass(gammaCorrection);
    this.addPass(effectVignette);
  }
}

class BackShards extends THREE.LineSegments{
  constructor(){
    let g = new THREE.InstancedBufferGeometry().copy(
      new THREE.........完整代码请登录后点击上方下载按钮下载查看

网友评论0