¿Explotando botones 3D? ¡Creé una interfaz de usuario increíble usando React x tres.js!

¿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!

Tabla de contenido

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".

Blueprint (flujo simple)
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ón
  • páginas/explosión Buttonpage: La carpeta que se creará esta vez
    • ExplodingButtonPage.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.

PARTE
PASO
Definición constante
  • 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
PASO
Definición de tipo
  • 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
PASO
Generación de partículas
  • 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.
PASO
Dibujo de partículas
  • 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.
PASO
Componentes principales
  • Es un componente que gobierna todo
  • Realiza la gestión del estado ( inactiva y explota
  • 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ón
    • Partencle_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

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 independiente
    • Child.Position.Add ()
      • En explosión, velocidad (vector de velocidad) por delta y actualizar la posición de las partículas
      • clone () evita que el vector de velocidad original sea destruido
    • Lerp(Interpolación lineal)
      • Acerca gradualmente a la posición original ( StartPosition Reset_speed es el indicador de velocidad
  • 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 a datos 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
  • 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 utilizando GroupRef
    • Groupref.Current.frianos
      • Acceder a todas las partículas (elementos infantiles) en el grupo
      • Consulte los datos de usuario para cada partícula

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!

¡Comparte si quieres!

Quien escribió este artículo

Este es un blog que comencé a estudiar la seguridad de la información. Como nuevo empleado, sería feliz si pudieras mirar con un corazón amplio.
También está Teech Lab, que es una oportunidad para estudiar diversión de programación, por lo que si está interesado en el desarrollo de software, ¡asegúrese de echar un vistazo!

Tabla de contenido