vlambda博客
学习文章列表

import { GLTFLoader } from 'https://unpkg.com/[email protected]/examples/jsm/loaders/GLTFLoader.js';import { convertMeshToPoints } from './utilities/convertMeshToPoints.js';import { createSparkleMaterial } from './utilities/createSparkleMaterial.js';import { createSizesAttribute } from './utilities/createSizesAttribute.js';import { setupAnimation } from './utilities/setupAnimation.js';
async function createSparkleHorse() { const loader = new GLTFLoader(); const data = await loader.loadAsync('./assets/models/Horse.glb');
 const model = data.scene.children[0]; const clip = data.animations[0];
 const material = createSparkleMaterial();
 const sparkleHorse = convertMeshToPoints(model, material);
 sparkleHorse.rotation.y = Math.PI / 2;
 sparkleHorse.scale.multiplyScalar(0.03);
 const sizeAttribute = createSizesAttribute(sparkleHorse.geometry);
 sparkleHorse.geometry.setAttribute('size', sizeAttribute);
 setupAnimation(sparkleHorse, clip, sizeAttribute);
 return sparkleHorse;}
export { createSparkleHorse };

import { Points } from 'https://unpkg.com/[email protected]/build/three.module.js';
function convertMeshToPoints(mesh, material) { const points = new Points(mesh.geometry, material);
 return points;}
export { convertMeshToPoints };

import { Float32BufferAttribute } from 'https://unpkg.com/[email protected]/build/three.module.js';

function createSizesAttribute(geometry) {const positions = geometry.attributes.position;const count = positions.count;const sizes = [];for (let i = 0; i < count; i++) {sizes.push(1);}const sizeAttribute = new Float32BufferAttribute(sizes, 1);return sizeAttribute;}

export { createSizesAttribute };

import {AdditiveBlending,PointsMaterial,TextureLoader,} from 'https://unpkg.com/[email protected]/build/three.module.js';function createSparkleMaterial() {const map = new TextureLoader().load('./assets/textures/sprites/spark1.png',);const material = new PointsMaterial({map,// size: 0.75,color: 'white',morphTargets: true,blending: AdditiveBlending,depthTest: false,// transparent: true,vertexColors: true,});material.onBeforeCompile = (shader) => {shader.vertexShader = shader.vertexShader.replace('uniform float size;','attribute float size;',);};return material;}export { createSparkleMaterial };

import { AnimationMixer } from 'https://unpkg.com/[email protected]/build/three.module.js';
function setupAnimation(model, clip, sizeAttribute) { const mixer = new AnimationMixer(model); const action = mixer.clipAction(clip); action.play();
 const minPointSize = 0.75; let time = 0;
 model.tick = (delta) => { mixer.update(delta); time += delta * 10;
 for (let i = 0; i < sizeAttribute.count; i++) { sizeAttribute.array[i] = minPointSize + 0.5 * Math.sin(i + time); }
 sizeAttribute.needsUpdate = true; };}
export { setupAnimation };

import { PerspectiveCamera } from 'https://unpkg.com/[email protected]/build/three.module.js';
function createCamera() { const camera = new PerspectiveCamera(35, 1, 0.1, 100);
 camera.position.set(7, 2, 10);
 return camera;}
export { createCamera };

import { DirectionalLight, HemisphereLight } from 'https://unpkg.com/[email protected]/build/three.module.js';
function createLights() { const ambientLight = new HemisphereLight( 'white', 'darkslategrey', 5, );
 const mainLight = new DirectionalLight('white', 4); mainLight.position.set(10, 10, 10);
 return { ambientLight, mainLight };}
export { createLights };

import { Color, Scene } from 'https://unpkg.com/[email protected]/build/three.module.js';
function createScene() { const scene = new Scene();
 // scene.background = new Color('skyblue');
 return scene;}
export { createScene };

import { OrbitControls } from 'https://unpkg.com/[email protected]/examples/jsm/controls/OrbitControls.js';
function createControls(camera, canvas) { const controls = new OrbitControls(camera, canvas);
 controls.enableDamping = true;
 controls.target.y = 3;
 // forward controls.update to our custom .tick method controls.tick = (delta) => controls.update(delta);
 return controls;}
export { createControls };

import { Clock } from 'https://unpkg.com/[email protected]/build/three.module.js';
const clock = new Clock();
class Loop { constructor(camera, scene, renderer) { this.camera = camera; this.scene = scene; this.renderer = renderer; this.updatables = []; }
 start() { this.renderer.setAnimationLoop(() => { // tell every animated object to tick forward one frame this.tick();
 // render a frame this.renderer.render(this.scene, this.camera); }); }
 stop() { this.renderer.setAnimationLoop(null); }
 tick() { // only call the getDelta function once per frame! const delta = clock.getDelta();
 // console.log( // `The last frame rendered in ${delta * 1000} milliseconds`, // );
 for (const object of this.updatables) { object.tick(delta); } }}
export { Loop };

import { WebGLRenderer } from 'https://unpkg.com/[email protected]/build/three.module.js';
function createRenderer() { const renderer = new WebGLRenderer({ antialias: true });
 renderer.physicallyCorrectLights = true;
 return renderer;}
export { createRenderer };

class Resizer { constructor(container, camera, renderer) { const setSize = () => { // Set the camera's aspect ratio camera.aspect = container.clientWidth / container.clientHeight;
 // update the camera's frustum camera.updateProjectionMatrix();
 // update the size of the renderer AND the canvas renderer.setSize(container.clientWidth, container.clientHeight);
 // set the pixel ratio (for mobile devices) renderer.setPixelRatio(window.devicePixelRatio); };
 // set initial size setSize();
 window.addEventListener('resize', () => { // set the size again if a resize occurs setSize(); // perform any custom actions this.onResize(); }); }
 onResize() {}}
export { Resizer };

import { createCamera } from './components/camera.js';import { createScene } from './components/scene.js';import { createSparkleHorse } from './components/SparkleHorse/sparkleHorse.js';
import { createControls } from './systems/controls.js';import { createRenderer } from './systems/renderer.js';import { Resizer } from './systems/Resizer.js';import { Loop } from './systems/Loop.js';
let camera;let controls;let renderer;let scene;let loop;
class World { constructor(container) { camera = createCamera(); renderer = createRenderer(); scene = createScene(); loop = new Loop(camera, scene, renderer); container.append(renderer.domElement); controls = createControls(camera, renderer.domElement);
 loop.updatables.push(controls);
 const resizer = new Resizer(container, camera, renderer); }
 async init() { const sparkleHorse = await createSparkleHorse();
 loop.updatables.push(sparkleHorse); scene.add(sparkleHorse); }
 render() { renderer.render(scene, camera); }
 start() { loop.start(); }
 stop() { loop.stop(); }}
export { World };

import { World } from './World/World.js';
async function main() { // Get a reference to the container element const container = document.querySelector('#scene-container');
 // create a new world const world = new World(container);
 // complete async tasks await world.init();
 // start the animation loop world.start();}
main();