¿Alguna vez has pensado: "Quiero agregar una pequeña sorpresa a la interfaz de usuario de tu sitio web ..."
Los botones simples no son suficientes, pero las animaciones demasiado complicadas son difíciles de manejar ... ¡la idea perfecta para tales ocasiones es el "botón 3D explosivo"!
Cuando se hace clic, este botón se rompe en partículas, lo que parece que está explotando. Además, tiene un mecanismo interesante en el que vuelve a su forma original después de un cierto período de tiempo.
Reaccionar y tres.js facilita el logro de una interfaz de usuario tan interactiva y hermosa.
¡Continuaremos creando lecciones y trabajos desde TypeScript X React Three Fiber en el futuro!
Haremos un anuncio en YouTube, así que suscríbase a nuestro canal de YouTube y espere notificaciones.
📺 Mira YouTube : puedes verlo desde este enlace
Si desea saber qué puede hacer React Three Fiber, ¡consulte lo siguiente!
¡Tenemos obras fáciles de usar disponibles!
- Traté de hacer que Bears caminara con React x tres.js!
- Intenté hacer que un viejo baile en React x tres.js!
- ¡Traté de mostrar un modelo 3D con React x tres.js!
- Hice un botón 3D que explota en React x tres.js!
- Reaccione tres fibra x drei x Introducción al mecanografiado! ¡Fondo 3D de estilo Poke Poke hecho con objetos estándar!
Demostración de explotar botones 3D
¡Haga clic para ver los sorprendentes botones 3D que explotan cuando hace clic en ellos!
Puede ver la demostración del producto terminado en el video a continuación.
📺 Mire la demostración en YouTube : puede verlo desde este enlace

Además, el código fuente para este proyecto está disponible en GitHub.
¡Descargue el código y pruébelo!
💾 Repositorio de GitHub : ¡verifique el código fuente en este enlace
Si te estás preguntando: "Lo he visto, ¿cómo lo hago?", ¡No te preocupes!
En este artículo, explicaremos paso a paso cómo crear este botón 3D desde cero.
Técnicas necesarias y biblioteca de claves
Este proyecto utiliza las siguientes tecnologías y bibliotecas: aquí hay una breve explicación de cada rol.
- Reaccionar
- Biblioteca para el desarrollo front-end
- Construcción eficiente de la interfaz de usuario con diseño basado en componentes
- Tres.js
- Una biblioteca para dibujar gráficos 3D en la web
- Hace que sea fácil manejar operaciones de webgl complejas
- Reaccionar tres fibra
- Biblioteca de envoltura para manejar tres.js en React
- Puede aprovechar las potentes características de tres.js en el estilo de desarrollo React
- Reaccionar thee drei
- Reaccionar tres biblioteca de extensión de fibra
- Reaccionar tres biblioteca de extensión de fibra
Diseño general de implementación
Este proyecto logrará un flujo simple de "partículas recolectadas para formar botones, y cuando se hace clic explota, volviendo a su forma original".
- Estado inicial (inactivo)
-
- Las partículas están dispuestas regularmente para formar la forma de los botones.
- El texto "¡Haz clic en mí!" se mostrará en el frente.
- Haga clic en la ocurrencia del evento (disparador)
-
- Al hacer clic en el botón, comenzará una acción de salpicaduras explosivas de todas las partículas.
- Este comportamiento se llama "explotar".
- Explotar
-
- Las partículas se mueven en una dirección aleatoria.
- La velocidad y la dirección se establecen al azar para cada partícula.
- Volver a la forma original (reinicio)
-
- Después de una cierta cantidad de tiempo, las partículas vuelven a su posición original y forman un botón nuevamente.
- Los movimientos posteriores se interpolan suavemente para lograr la animación natural.
Preparación ambiental
Esta sección proporciona la configuración inicial para su proyecto. Cree una aplicación React usando el comando NPX, instale las bibliotecas requeridas y organice la estructura de carpetas.
Creando una aplicación React
Primero, cree una aplicación React usando el comando NPX.
NPX CREATE-APP EXPLOTING-BUTTON -EPLAPLATE TypeScript
explosión-botton
es el nombre del proyecto-template
use una plantilla habilitada para typeScript especificando
Instalación de las bibliotecas requeridas
Instale React Three Fiber y otras bibliotecas.
CD Exploting-Button NPM Instale tres @React-Three/Fiber @React-Three/Drei
- Tres : tres.js cuerpo principal
- @react-three/fibra : un envoltorio para usar tres.js con React
- @React-Three/Drei : ayudantes útiles como controles de cámara y dibujo de texto
Revisar la estructura de la carpeta y eliminar archivos innecesarios
Organice y agregue carpetas del estado inicial de la siguiente manera:
Básicamente, es el valor predeterminado, pero para los archivos que no sabe, consulte GitHub.
explosión-botton/ ├─omo node_modules/ ├── pública/ ├── src/ ├── componentes// directorio para agregar otros componentes │ ├ ├ ├/ // para archivos que administran datos si es necesario │ ├ ├─ Pages/ // componentes administrados en una página de página by-bypage │ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ ├ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ExplodingButtonPage.tsx // Código de página principal │ │ └── ExplodingButtonPage.css // Hoja de estilo │ ├── APP.TSX // Puntos de entrada de aplicaciones │ ├iqu. ├── tsconfig.json // Configuración de mecanografiado └── Readme.md // Descripción general del proyecto
Los archivos a modificar esta vez son los siguientes:
App.tsx
: puntos de entrada de la aplicaciónpáginas/explosión Buttonpage
: La carpeta que se creará esta vezExplodingButtonPage.tsx
: componente de la página principal.ExplodingButtonPage.css
: estilo específico de la página.
Explicación detallada del código fuente para cada paso
En las siguientes secciones, explicaremos en detalle las cinco partes a continuación en orden.
- Define la configuración básica, como el botón y el tamaño de la partícula, la velocidad y el tiempo de funcionamiento.
- Estas constantes se usan en todo el proyecto y se pueden ajustar fácilmente modificándolas
- Define la estructura de datos para cada partícula que compone el botón
- Uso de TypeScript para mejorar la legibilidad y la capacidad de mantenimiento
- Genera partículas de cubos y partículas de texto que componen el botón
- Establezca aleatoriamente la posición inicial de cada partícula y el vector de velocidad en el momento de la explosión
- También implementaremos la lógica para colocar la "Haga clic en mí!" personajes en la superficie del botón.
- Dibuje las partículas generadas en el espacio 3D
UseFrame
Controls Animations (movimientos de salida) al explotar y las animaciones que vuelven a su posición original- Texto y cubos separados utilizando métodos de dibujo apropiados.
- Es un componente que gobierna todo
- Realiza la gestión del estado (
inactiva
yexplota
- La configuración de fondo y control de la cámara también se implementará aquí.
- Incluye
explosivos de partículas
para mostrar partículas
Verifique toda la fuente
A continuación se muestra el código fuente completo para los botones 3D explosivos creados en este artículo. Todo el código está juntos, por lo que es fácil tener una idea de cómo funciona.
Si desea ver otras fuentes, consulte GitHub.
import './app.css'; import {explotarButtonPage} de './pages'; función app () {return (<div className="App"><ExplodingButtonPage /></div> ); } Exportar aplicación predeterminada;
importar react, {useref, useState} de "react"; import {Canvas, UseFrame} de "@react-three/fiber"; import {orbitcontrols, estrellas, texto} de "@react-three/drei"; importar * como tres de "tres"; // ===== // Parte 1: Definición constante // ===== const partícula_size = 0.1; // 1 Tamaño de partícula const partticle_num_width = 40; // Número de partículas (horizontal) const partículas_num_height = 20; // Número de partículas (horizontal) const partículas_num_thickness = 5; // Número de partículas (horizontal) const button_size_width = partícula_size * partícula_num_width; // tamaño de botón = 1 partícula * Número de partículas const button_size_height = partícula_size * partícula_num_height; // tamaño de botón = 1 partícula * Número de partículas const button_size_thickness = partícula_size * partícula_num_thickness; // tamaño del botón = 1 partícula * Número de partículas const text = "¡Haz clic en mí!"; // Texto para mostrar const text_size = button_size_width / text.length; // tamaño por caracteres const text_float_offset = 0.01; // la distancia que permite que el texto flote desde la superficie del botón const part sarticle_speed = 2.0; // velocidad en explosion const partícule_time = 5 * 1000; // Duración de la explosión en segundos const reset_speed = 0.05; // velocidad para volver a la posición original // ===== // Parte 2: Tipo Definición // ==== Tipo de partícula = {id: número; // Posición de inicio de identificación única: tres.vector3; // Posición inicial de posición: tres.vector3; // posición actual: tres.vector3; // Escala de vector de velocidad de explosión: número; // tamaño char?: Cadena; // caracteres para partículas de texto}; // ===== // Parte 3: Función de generación de partículas // ===== const generateButtonParticles = (): partícula [] => {const partículas: partícula [] = []; // --- Generar partículas de botón --- para (LET x = 0; x <partticle_num_width; x ++) {for (let y = 0; y <partícula_num_height; y ++) {para (let z = 0; z <partícula_num_thickness; z ++) {constante = nueva tres.vector3 (x * partícula_ssize-button-button-booth / 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2. Partícula_size - button_size_height / 2, z * partícula_size); partículas.push ({id: partículas.length, startPosition: posicion.clone (), posición: posicion.clone (), velocidad: new Three.vector3 ((math.random () - 0.5) * partícula_speed, (math.random () - 0.5) * partícula_speed, (math.random () - 0.5) * partícula_speed), scale,}); }}} // --- Generar partículas de texto --- text.split (""). Foreach ((char, i) => {const posicion = new tres.vector3 (i * text_size-button_size_width / 2 + text_size / 2, 0, // y-oxis Center Button_size_thickness + text_floats // Z-x-axs: LITTURY FLOATS DEL SUFFIE); particles.push({ id: particles.length, startPosition: position.clone(), position: position.clone(), velocity: new THREE.Vector3( (Math.random() - 0.5) * PARTICLE_SPEED, (Math.random() - 0.5) * PARTICLE_SPEED, (Math.random() - 0.5) * PARTICLE_SPEED ), scale: TEXT_SIZE, char, }); partículas de retorno; }; // ==== // Parte 4: Componentes de dibujo de partículas // ====== const explotingparticles: react.fc <{partículas: partícula []; estado: string}> = ({partículas, estado}) => {const groupRef = useref<THREE.Group> (nulo); // useFrame: procesar cada cuadro (explosión o retorno a la posición inicial) UseFrame (((_, delta) => {groupref.Current? Child.Position.Add (partícula.velocity.clone (). MultiplyScalar (delta)); }); devolver (<group ref={groupRef}> {partículas.map ((partícula) => partícula.char? (// Text Partencle <group key={particle.id} position={particle.position} userData={{ particle }}><Text fontSize={particle.scale} color="white"> {partícula.char}</Text></group> ): (// partículas en forma de botón <mesh key={particle.id} position={particle.position} userData={{ particle }}><boxGeometry args={[particle.scale, particle.scale, particle.scale]} /><meshStandardMaterial color={"#3498db"} /></mesh> ))}</group> ); }; // ==== // Parte 5: Componentes principales // ===== Const ExplodingButtonPage: react.fc = () => {const [partículas] = useState<Particle[]> (GenerateButtonParticles ()); const [state, setState] = useState <"inactivo" | "explotar"> ("inactivo"); const handLecLick = () => {if (state === "inactivo") {setState ("explotar"); setTimeOut (() => setState ("inactivo"), partícula_time); }}; devolver ( <div style={{ width: "100vw", height: "100vh", background: "black" }}><Canvas camera={{ position: [0, 0, 8] }}> {/ * Efecto de fondo */} <Stars radius={100} depth={50} count={1000} factor={4} fade /><ambientLight intensity={0.8} /><spotLight position={[10, 10, 10]} intensity={2} castShadow /> {/ * Pantalla de partículas */}<group onClick={handleClick}><ExplodingParticles particles={particles} state={state} /></group> {/ * Operación de la cámara */}<OrbitControls /></Canvas></div> ); }; Exportar Predeterminado ExplodingButtonPage;
Parte 1: Definición constante
Primero, veremos la importación de cada biblioteca y las definiciones constantes.
importar react, {useref, useState} de "react"; import {Canvas, UseFrame} de "@react-three/fiber"; import {orbitcontrols, estrellas, texto} de "@react-three/drei"; importar * como tres de "tres"; // ===== // Parte 1: Definición constante // ===== const partícula_size = 0.1; // 1 Tamaño de partícula const partticle_num_width = 40; // Número de partículas (horizontal) const partículas_num_height = 20; // Número de partículas (horizontal) const partículas_num_thickness = 5; // Número de partículas (horizontal) const button_size_width = partícula_size * partícula_num_width; // tamaño de botón = 1 partícula * Número de partículas const button_size_height = partícula_size * partícula_num_height; // tamaño de botón = 1 partícula * Número de partículas const button_size_thickness = partícula_size * partícula_num_thickness; // tamaño del botón = 1 partícula * Número de partículas const text = "¡Haz clic en mí!"; // Texto para mostrar const text_size = button_size_width / text.length; // tamaño por caracteres const text_float_offset = 0.01; // la distancia que permite que el texto flote desde la superficie del botón const part sarticle_speed = 2.0; // velocidad en explosion const partícule_time = 5 * 1000; // Duración de explosión (segundos) const reset_speed = 0.05; // velocidad para volver a la posición original
- Definición de tamaño
- Para determinar el tamaño general del botón, calcule multiplicando el tamaño de partícula y el número de su
Partícula_size
es el tamaño de un cubo de una partícula- Establezca el número de partículas (horizontal, vertical, profundidad) en cada dirección individualmente
- Definición de velocidad y tiempo
Partícula_speed
es la velocidad del movimiento cuando la explosiónPartencle_time
es un momento en que la animación de explosión continúa
Parte 2: Definición de tipo
El siguiente es la definición de tipo.
No es necesario con JavaScript, pero esta vez se crea con TypeScript, por lo que se requieren definiciones de tipo.
Tipo de partícula = {id: número; // Identificador único para cada posición de inicio de partículas: tres.vector3; // Posición inicial de posición: tres.vector3; // Velocidad de posición actual: tres.vector3; // Escala de velocidad de movimiento: número; // tamaño char?: Cadena; // Carácter para partículas de texto};
- Propósito de la definición de tipo
- Organizar claramente los datos necesarios para las partículas
Tres.vector3
es un tipo de tres.js que expresa posición y velocidad en el espacio 3D.Char
se define como un tipo opcional (?
Parte 3: Generación de partículas
Define una función que genera botones y partículas de texto.
Una partícula es un botón que es un grano que se divide. Cada personaje es una partícula.
En lugar de dividir un botón, es la imagen de múltiples moléculas que se juntan para formar un solo botón.
Esta es una función que organiza cada uno de ellos y crea botones.
const GenerateButtonParticles = (): partícula [] => {const partículas: partícula [] = []; // Generar partículas de cubos para el botón para (LET x = 0; x <partícula_num_width; x ++) {para (let y = 0; y <partícula_num_height; y ++) {para (let z = 0; z <partícula_num_thickness; z ++) {constante = new tres.vector3 (X * partícula_size - button_size_size; Partícula_size - button_size_height / 2, z * partícula_size); partículas.push ({id: partículas.length, startPosition: posicion.clone (), posición: posicion.clone (), velocidad: new Three.vector3 ((math.random () - 0.5) * partícula_speed, (math.random () - 0.5) * partícula_speed, (math.random () - 0.5) * partícula_speed), scale,}); }}} // Crear partícula de texto text.split (""). Foreach ((char, i) => {const posicion = new tres.vector3 (i * text_size - button_size_width / 2 + text_size / 2, 0, button_size_thickness + text_float_offset); partícula.push ({{‘Id: Id: longitud de startposition, startposser (start. Posición: Position.Clone (), Velocity: New Three.vector3 ((Math.random () - 0.5) * Partartle_speed, (Math.random () - 0.5) * Partencle_speed, (Math.random () - 0.5) * partícula_speed), escala: text_size, char,}); partículas de retorno; };
- Generar partículas de botones
- Use bucles triples para organizar partículas en formas de botones (longitud, ancho, ancho)
- Establezca
posición de inicio
) y la posición actual (posición
de cada partícula La velocidad
se establece en una orientación aleatoria
- Generación de partículas de texto
- Procesar cada personaje en
texto
- Cada personaje se coloca en la superficie del botón y se trata como partículas
- Procesar cada personaje en
Parte 4: Dibujo de partículas
Define una función que en realidad dibuja partículas.
const explosiones explosiones: react.fc <{partículas: partícula []; estado: string}> = ({partículas, estado}) => {const groupRef = useref<THREE.Group> (nulo); useFrame (((_, delta) => {groupRef.Current? Child.Position.lerp (partícula.StartPosition, reset_speed); devolver (<group ref={groupRef}> {partículas.map ((partícula) => partícula.char? ( <group key={particle.id} position={particle.position} userData={{ particle }}><Text fontSize={particle.scale} color="white"> {partícula.char}</Text></group> ): ( <mesh key={particle.id} position={particle.position} userData={{ particle }}><boxGeometry args={[particle.scale, particle.scale, particle.scale]} /><meshStandardMaterial color={"#3498db"} /></mesh> ))}</group> ); };
- Control de animación usando UseFrame
UseFrame
es@React-Three/Fiber
, que describe el procesamiento que desea realizar cada cuadro en el espacio 3D.Delta
: El tiempo desde el último cuadro. Esto hace que el movimiento de animación sea independienteChild.Position.Add ()
- En explosión,
velocidad
(vector de velocidad) pordelta
y actualizar la posición de las partículas -
clone ()
evita que el vector de velocidad original sea destruido
- En explosión,
Lerp
(Interpolación lineal)- Acerca gradualmente a la posición original (
StartPosition
Reset_speed
es el indicador de velocidad
- Acerca gradualmente a la posición original (
- Tipos de partículas de dibujo (cubo y texto)
- Partículas de cubo (parte de forma del botón)
Use etiquetas para crear una geometría de cubo (
) dibujar- Use
MeshStandardMaterial
- Pase los datos de
partículas
adatos de usuarios
uso el marco
para actualizar la ubicación
- Partículas de texto
@React-Three/Drei
's
Uso de componentes- Establezca el tamaño de fuente basado en la escala de partículas (
escala
- Control individualmente dentro
del grupo
para que cada personaje siga la explosión
- Partículas de cubo (parte de forma del botón)
- Manejo de partículas utilizando componentes de grupo
es un componente grupal en tres.js que le permite administrar múltiples objetos a la vez- En este caso, todas las partículas se pueden hacer en una
Se organiza en el interior y se manipula utilizandoGroupRef
- Groupref.Current.frianos
- Acceder a todas las partículas (elementos infantiles) en
el grupo
- Consulte
los datos de usuario
para cada partícula
- Acceder a todas las partículas (elementos infantiles) en
Parte 5: Componente principal
Finalmente, será el componente principal.
Define fondos y cámaras (OrbitControls).
const explotingbuttonPage: react.fc = () => {const [partículas] = useState<Particle[]> (GenerateButtonParticles ()); const [state, setState] = useState <"inactivo" | "explotar"> ("inactivo"); const handLecLick = () => {if (state === "inactivo") {setState ("explotar"); setTimeOut (() => setState ("inactivo"), partícula_time); }}; devolver ( <div style={{ width: "100vw", height: "100vh", background: "black" }}><Canvas camera={{ position: [0, 0, 8] }}><Stars radius={100} depth={50} count={1000} factor={4} fade /><ambientLight intensity={0.8} /><spotLight position={[10, 10, 10]} intensity={2} castShadow /><group onClick={handleClick}><ExplodingParticles particles={particles} state={state} /></group><OrbitControls /></Canvas></div> ); };
- Gestión de estado
Estado
alterna la explosión y el reinicio a la posición inicial
- Haga clic en el evento
- Activar una explosión y devuélvala a su estado original después de un cierto período de tiempo.
por último
¡En este artículo, hemos combinado React y Three.js para crear un "botón 3D explosivo"! A través de este proyecto, probablemente aprendiste los siguientes puntos:
- Cómo operar espacios 3D usando React Three Fiber
- Implementación de animaciones interactivas con partículas
- gestión estatal (
useSestate
) y control de animación (useframe
)
¡Intente obtener los botones 3D terminados en persona!
📺 Mire la demostración en YouTube : puede verlo desde este enlace

Además, el código fuente para este proyecto está disponible en GitHub.
¡Descargue el código y pruébelo!
💾 Repositorio de GitHub : ¡verifique el código fuente en este enlace
Si lo encontró útil, ¡suscríbase a nuestro canal!
¡Continuaremos creando lecciones y trabajos desde TypeScript X React Three Fiber en el futuro!
Haremos un anuncio en YouTube, así que suscríbase a nuestro canal de YouTube y espere notificaciones.
📺 Mira YouTube : puedes verlo desde este enlace
Si desea saber qué puede hacer React Three Fiber, ¡consulte lo siguiente!
¡Tenemos obras fáciles de usar disponibles!
- Traté de hacer que Bears caminara con React x tres.js!
- Intenté hacer que un viejo baile en React x tres.js!
- ¡Traté de mostrar un modelo 3D con React x tres.js!
- Hice un botón 3D que explota en React x tres.js!
- Reaccione tres fibra x drei x Introducción al mecanografiado! ¡Fondo 3D de estilo Poke Poke hecho con objetos estándar!