Traté de hacer que Bears caminara con React x tres.js! ¡Modelado 3D fácil con AI malla!

Traté de hacer que Bears caminara con React x tres.js! ¡Modelado 3D fácil con AI malla!

A medida que la tecnología AI evoluciona, el modelado 3D se ha vuelto más fácil y más agradable.
Con la introducción de "Meshy AI", que puede ser utilizada fácilmente por principiantes de programación, el modelado 3D, que hemos encontrado previamente difícil, ha reducido repentinamente el obstáculo.

📺 Verifique la malla : puede verificarlo en la página oficial desde este enlace

En este artículo, explicaremos en detalle cómo ejecutar un modelo 3D Bear creado con AI Meshy usando React X Three.js

La forma en que el oso comienza a moverse en la pantalla es divertido de ver y también debería ser una oportunidad para expandir las posibilidades del desarrollo web.
¡Incluso los principiantes definitivamente deberían probarlo e intentar crear su propia animación 3D original!

¡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 pantalla de modelo 3D

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 ver este modelo 3D.

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
  • De malla
    • Un servicio que le permite generar fácilmente modelos 3D de alta calidad utilizando AI

Diseño general de implementación

Este proyecto logrará un proceso simple: "Use herramientas de IA para generar un modelo 3D y mostrarlo en el navegador usando React y Three.js".

Blueprint (flujo simple)
Cargando el modelo
  • Importar un modelo 3D Bear generado con AI Meshy utilizando FBXLoader
  • Ajustar la escala , la posición inicial y la rotación
Gestión de animaciones
  • Play "Walking" Animation of Bears usando AnimationMixer en tres.js
  • Gestión de estado: ISPlayingControla la reproducción de animación y la parada del uso de la variable estatal
    • isplaying = true : la animación se reproduce
    • isplaying = falso : la animación se detiene
Actualizaciones de cuadro por cuadro
  • Reaccionar tres fibra **UseFrame** Use ganchos para actualizar el siguiente comportamiento por cuadro
    • Avance del modelo aumente la z mientras el oso camina en la pantalla
    • Actualización de animación : avance de los marcos de animación actuales con AnimationMixer
Operación de botón
  • Usando el botón React,ISPlayingLe permite cambiar el estado de
    • Una ui simple que cambia de reproducción/parada de animación cuando presiona un botón
Construyendo el medio ambiente
  • Fondo : configure el color del cielo en tres.js
  • Luz : Coloque la luz ambiental y las fuentes de luz de punto para que los modelos 3D sean más fáciles de ver

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 react-app meshy-3d-model-animation -template typeScript
  • Meshy-3D-Model-Animathion 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 Meshy-3D-Model-Animathion 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.

meshy-3d-model-animation/ ├── node_modules/ ├── public/ ├── models/ // 3D models and related files │ ├── cuddly_bear/ // Bear's 3D model folder │ │ ├── Animation_Walking_withSkin.fbx // FBX files with walking animation │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ThreeDModelAnimation/ // FBX files for other purposes │ │ │ │ │ │ │ ThreeDModelAnimation/ // 3D animation page │ │ │ │ │ │ │ │ │ │ │ │ │ │ Threedmodelanimation.tsx // componente de reacción principal │ │ │ │ │ threedmodelanimation.css // hoja de estilo de página │ │ │ │ │ │ │. Estilo │ │── index.css // CSS global │── paquete.json // Configuración del proyecto │── tsconfig.json // Configuración de mecanografiado └iqute. 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> index.ts : archivo de índice para exportar la página a.
  • páginas/tridelanimación: La carpeta que se creará esta vez
    • ThredModelanimation.tsx : Componente de la página principal.
    • ThredModelanimation.css : Page Styles Hoje

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
PARTE
Generar modelos 3D con malla
  • Genere modelos de osos 3D con IA usando AI Meshy
  • Exportar en formato FBX y colóquelo en el público/modelos/cuddly_bear
PARTE
Definición constante
  • Define la escala, la posición inicial, el ángulo de rotación, etc. del modelo 3D
  • Establezca las constantes que administran el tamaño del suelo y las piedras aleatorias, y la configuración inicial para la cámara y la luz.
  • Al convertir constantes, hace que sea más fácil ajustar y administrar más tarde.
PARTE
Modelo de animación
  • Cargando el modelo Bear generado en Meshy usando FBXLoader
  • Administrar animaciones usando AnimationMixer
  • Dibujar un modelo con primitivo
  • Implementar reproducción/dejar de cambiar utilizando la administración de estado de React
PARTE
Entorno de tierra
  • Use plangeometría para generar tierra
  • Use MeshStandardMaterial para establecer el color y la textura del suelo
  • Desempeña un papel en mantener el terreno quieto y resaltar el fondo y los modelos
PARTE
Arreglo de piedra al azar
  • Usestate para generar cálculos de posiciones y tamaños aleatorios al principio
  • Creación de piedras con esferegeometría y MeshandardMaterial
PARTE
Componentes principales
  • Integre los modelos de animación de tierra, piedras y osos utilizando lienzo
  • Use OrbitControls de la biblioteca DREI para habilitar la operación de la cámara
  • Agregar botones, alternar Isplaying State para reproducir/detener la animación

Verifique toda la fuente

A continuación se muestra el código fuente completo para ejecutar el modelo 3D Bear creado con AI Meshy creado en este artículo usando React X Three.js 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 {threedModelanimation} de './pages'; función app () {return (<div className="App"><ThreeDModelAnimation /></div> ); } Exportar aplicación predeterminada;
Importar ExplodingButtonPage de "./explodingbuttonpage/explodingButtonPage"; Importar GamationroomLogin de "./gamingroomlogin/gamingroomlogin"; import meshy3dmodel de "./meshy3dmodel/meshy3dmodel"; Importar triDelanimación de "./ThreedModelanimation/ThreedModelanimation"; Export {ExplodingButtonPage, GamatingroomLogin, Meshy3DModel, ThredModelanimation}
// 3dmodelanimation.tsx // ===== // Parte 1: Genere un modelo con Meshy // ==== // Genere un modelo 3D usando Meshy Ai // ===== // Parte 2: Definición constante // ==== Import React, {Useref, use efecting, usestate de 'reacto'; import {Canvas, UseFrame} de '@react-three/fiber'; import {OrbitControls} de '@react-three/drei'; import {fbxloader} de 'tres/ejemplos/jsm/loaders/fbxloader'; import {AnimationMixer, Clock, Doubleide, Vector3} de 'Three'; import './threedmodelanimation.css'; // Definición constante // Configuración relacionada con el modelo const model_scale = 0.1; // Model Scale const model_initial_position = new Vector3 (0, 0.5, 0); // posición inicial del modelo const model_rotation_x = -0.3; // rotación del eje x del modelo // Configuración de tierra const ground_color = 'verde'; const ground_position = new Vector3 (0, 0, 0); const ground_size = 200; // tamaño de tierra const ground_segments = 50; // divisiones terrestres // ajuste de piedra const stone_count = 50; // número de piedras const stone_scale_min = 0.1; // escala mínima const stone_scale_max = 0.6; // Escala máxima // Configuración de cámara y luz const cámaras_position = new Vector3 (0, 20, 50); const ambiente_light_intensidad = 0.7; // intensidad de luz ambiental const_light_position = new Vector3 (10, 20, 10); const apo_light_intensity = 1; // Strenza de fuente de luz de puntos // Configuración de fondo const background_color = 'SkyBlue'; // Interfaz de color de fondo AnimatedFBXModelProps {ruta: string; ¿Está jugando?: booleano; } // ==== // Parte 3: Modelo animado // ==== Con Const AnimatedfbxModel: React.fc<AnimatedFBXModelProps> = ({ruta, isPlaying = false}) => {const mezclas = useref<AnimationMixer | null> (nulo); const reloj = useref (nuevo reloj ()); const [modelo, setmodel] = useState<any> (nulo); const [acción, setAction] = useState<any> (nulo); // Actualiza la posición del modelo y la animación para cada cuadro Useframe (() => {if (model && isplaying) {model.position.z += 0.05; // mover el modelo hacia adelante} if (mixer.current && isplaying) {const delta = clock.current.getDelta (); mixer.current.update (deltA); ////////conalte}); // Load FBX Model UseEffect (() => {const Loader = new FbxLoader (); Loader.Load (Path, (fbx) => {if (! Model) {fbx.scale.set (model_scale, model_scale, model_scale); fbx.position.copy (model_initial_posic mixer.current = new AnimationMixer (FBX); console.error ('Error de carga del modelo FBX:', error); // toggle reproducir/stop animation useEffect (() => {if (action) {action.paused =! IsPlaying; if (isPlaying) {Action.play ();} else {Action.Stop ();}}}, [isPlaying, Action]); ¿Modelo de regreso?<primitive object={model} /> : nulo; }; // ==== // Parte 4: Configuración de tierra // ===== const Ground: react.fc = () => {return ( <mesh rotation={[-Math.PI / 2, 0, 0]} position={GROUND_POSITION}><planeGeometry args={[GROUND_SIZE, GROUND_SIZE, GROUND_SEGMENTS, GROUND_SEGMENTS]} /><meshStandardMaterial color={GROUND_COLOR} side={DoubleSide} /></mesh> ); }; // ==== // Parte 5: disposición de piedra aleatoria // ===== const randomstones: react.fc = () => {// Generar cálculos en posiciones aleatorias y escalas en la primera representación de const [piedras] = useSestate () => {return Array.from ({longitud: Stone_Count}, () => {Const.Random () 2; <mesh key={`${x}-${z}`} position={[x, y, z]} scale={[scale, scale, scale]}><sphereGeometry args={[1, 8, 8]} /><meshStandardMaterial color="gray" /></mesh> ); }); return <> {piedras}</> ; }; // ==== // Parte 6: Componentes principales // ===== const ThredModelanimation: react.fc = () => {const [isPlaying, setIsplaying] = useState (false); devolver (<div className="canvas-container"> <button style={{ position: 'absolute', top: '10px', left: '10px', zIndex: 100 }} onClick={() =>setPlaying (! isplaying)}> {isPlaying? 'PAUSE ANIMATION': 'Play Animation'}</button> <Canvas camera={{ position: CAMERA_POSITION.toArray() }}><ambientLight intensity={AMBIENT_LIGHT_INTENSITY} /><pointLight position={POINT_LIGHT_POSITION.toArray()} intensity={POINT_LIGHT_INTENSITY} /><OrbitControls /> {/ * Pantalla de tierra */}<Ground /> {/ * Disposición de piedra aleatoria */}<RandomStones /> {/ * Configuración de color de fondo */}<color attach="background" args={[BACKGROUND_COLOR]} /> {/ * Modelo de animación */}<AnimatedFBXModel path="/models/cuddly_bear/Animation_Walking_withSkin.fbx" isPlaying={isPlaying} /></Canvas></div> ); }; Exportar triunfo de treedModelanimación;
/ * 3dmodelanimation.css */ .canvas-continer {ancho: 100vw; Altura: 100 VH; Pantalla: Flex; Justify-Content: Center; Alineación de ítems: Centro; Color de fondo: #000; }
  

Parte 1: Generación de modelos en Meshy

Esta vez, el modelo 3D utilizará un servicio de generación automática de IA llamado Meshy.
El enlace está a continuación, así que consultelo.

200 créditos por mes están disponibles de forma gratuita.

📺 Verifique la malla : puede verificarlo en la página oficial desde este enlace

Esta vez, se requiere la versión Pro (alrededor de 3.000 yenes al mes). (La animación solo está disponible en la versión Pro)

Seleccione una comunidad y seleccione un modelo que ya se haya creado.
Puede generar esto solo a partir de texto o imágenes.

Esta vez, elegimos el modelo 3D Bear a continuación.
Cuando pase el cursor sobre el cursor, verá un botón llamado "Modelo de regeneración", así que seleccione.

Es probable que sea redirigido al espacio de trabajo, así que simplemente seleccione el botón "Generar".

Habrá cuatro modelos 3D Bear, así que elija el modelo que desee.

Seleccione "Confirmar Textura y Remesh como está".

Esto generará un modelo similar al modelo que seleccionó.

A continuación, seleccione Animate> Rigging para agregar animación.

Esta vez, aunque es un poco difícil, ya que el humanoide está cerca, elegiré el humanoide.

No creo que haya ninguna necesidad de cambiar la siguiente pantalla, así que continúe con la página siguiente.

Este será el diseño del marcador. Esta vez mis rodillas son difíciles, pero terminé apilándolas en mis tobillos.

Esto generará un modelo 3D animado.
La forma en que camino es incómoda, pero esto es suficiente para mí, en cuanto al personaje. (jajaja)

Si el movimiento no funciona, expórtelo usando FBX o algo similar.
Esta vez lo explicaré en FBX, pero dado que GLB es más ligero, puede ser bueno para el uso web.

Parte 2: Definición constante

Primero, veremos la importación de cada biblioteca y las definiciones constantes.
La definición de constantes gestiona centralmente los valores utilizados dentro de su aplicación, mejorando la reutilización y la legibilidad. Dado que los valores de configuración para modelos y escenas 3D se usan en todas partes en el código, lo que hace que las constantes sean más fáciles de mantener.

// ==== // Parte 2: Definición constante // ==== Import React, {useref, useEffect, useState} de 'React'; import {Canvas, UseFrame} de '@react-three/fiber'; import {OrbitControls} de '@react-three/drei'; import {fbxloader} de 'tres/ejemplos/jsm/loaders/fbxloader'; import {AnimationMixer, Clock, Doubleide, Vector3} de 'Three'; import './threedmodelanimation.css'; // Definición constante // Configuración relacionada con el modelo const model_scale = 0.1; // Model Scale const model_initial_position = new Vector3 (0, 0.5, 0); // Posición inicial del modelo const model_rotation_x = -0.3; // Modelo de rotación del eje X // Configuración de tierra const ground_color = 'verde'; const ground_position = new Vector3 (0, 0, 0); const ground_size = 200; // tamaño de tierra const ground_segments = 50; // Número de divisiones terrestres // Configuración de piedra const Stone_count = 50; // número de piedras const stone_scale_min = 0.1; // escala mínima de piedras const stone_scale_max = 0.6; // Escala máxima de piedras // Configuración de cámara y luz const camera_position = new Vector3 (0, 20, 50); const ambiente_light_intensidad = 0.7; // intensidad de luz ambiental const_light_position = new Vector3 (10, 20, 10); const apo_light_intensity = 1; // Strenza de fuente de luz de puntos // Configuración de fondo const background_color = 'SkyBlue'; // Interfaz de color de fondo AnimatedFBXModelProps {ruta: string; ¿Está jugando?: booleano; }

Dependiendo del modelo 3D que genere, pueden ser necesarios ajustes finos, así que utilice lo siguiente como referencia para jugar con los números.

  • Configuración relacionada con el modelo
    • Modelo_scale
      • Especifica el tamaño del modelo. Establecido en 0.1
      • Ejemplo: ajuste el modelo Bear para mostrar el tamaño apropiado para la pantalla.
    • Model_initial_position
      • Especifica la posición inicial del modelo.
      • Ejemplo: colóquelo ligeramente sobre el suelo con nuevo Vector3 (0, 0.5, 0)
    • Model_rotation_x
      • Especifica el ángulo de rotación inicial del modelo.
      • Ejemplo: -0.3 para inclinarse ligeramente hacia adelante.
  • Entorno de tierra
    • Ground_color
      • Especificar el color de tierra. Especifique el verde aquí
    • Ground_position
      • Especifica la posición del suelo. Colocado en el origen con nuevo vector3 (0, 0, 0)
    • Ground_Size
      • Especifique el tamaño del suelo (ancho y altura). 200 tamaño cuadrado.
    • Ground_segments
      • Especifica el número de tierra que se divide. Establecido en finura moderada a los 50.
  • Configuración de piedra
    • Stone_Count
      • Especifica el número de piedras que se colocarán. Se organizan 50 piezas.
    • Stone_scale_min
      • Especifica la escala mínima (tamaño) de la piedra. 0.1 representa una pequeña piedra.
    • Stone_scale_max
      • Especifica la escala máxima (tamaño) de la piedra. 0.6 representa una piedra ligeramente más grande.
  • Configuración de cámara y luz
    • Camera_posición
      • Especifica la posición inicial de la cámara. El nuevo Vector3 (0, 20, 50) da una perspectiva ligeramente más alta de mirar al oso.
    • Ambiente_light_intensidad
      • Especifica la intensidad de la luz ambiental. Brillo natural a 0.7
    • Point_light_position
      • Especifica la ubicación de la fuente de luz puntual. Ilumine el modelo desde arriba con nuevo Vector3 (10, 20, 10)
    • Point_light_Intensity
      • Especifica la intensidad de la fuente de luz puntual. Establezca el brillo en 1
  • Configuración de fondo
    • Background_color
      • Especifica el color de fondo para la escena. Especificar skyblue aquí

Parte 3: Modelo de animación

Carga el modelo 3D generado con Meshy y utiliza la función de animación de tres.js para ejecutarlo. La combinación de la gestión de la animación con la gestión del estado de React proporciona la capacidad de moverse y detener el modelo.

// ==== // Parte 3: modelo animado // ===== const animatedfbxmodel: react.fc<AnimatedFBXModelProps> = ({ruta, isPlaying = false}) => {const mezclas = useref<AnimationMixer | null> (nulo); const reloj = useref (nuevo reloj ()); const [modelo, setmodel] = useState<any> (nulo); const [acción, setAction] = useState<any> (nulo); // Actualiza la posición del modelo y la animación para cada cuadro Useframe (() => {if (model && isplaying) {model.position.z += 0.05; // mover el modelo hacia adelante} if (mixer.current && isplaying) {const delta = clock.current.getDelta (); mixer.current.update (deltA); ////////conalte}); // Load FBX Model UseEffect (() => {const Loader = new FbxLoader (); Loader.Load (Path, (fbx) => {if (! Model) {fbx.scale.set (model_scale, model_scale, model_scale); fbx.position.copy (model_initial_posic mixer.current = new AnimationMixer (FBX); console.error ('Error de carga del modelo FBX:', error); // toggle reproducir/stop animation useEffect (() => {if (action) {action.paused =! IsPlaying; if (isPlaying) {Action.play ();} else {Action.Stop ();}}}, [isPlaying, Action]); ¿Modelo de regreso?<primitive object={model} /> : nulo; };
  • Cargando el modelo
    • Cargar public/modelos/cuddly_bear/animation_walking_withskin.fbx usando fbxloader
    • Dibuje el modelo 3D importado usando el primitivo en tres.js.
  • Gestión de animaciones
    • Use AnimationMixer
    • Para cambiar entre la reproducción y detener las animaciones, use IsPlaying se gestiona utilizando USEstate
  • Avance del modelo
    • Use el gancho Useframe en tres.js el valor del eje Z por cuadro, logrando un movimiento en movimiento que avanza el modelo.

Parte 4: configuración de tierra

Coloque el suelo donde caminarán los osos. El suelo se expresa utilizando geometría plana simple y se coloca en armonía con la cámara y el modelo. El suelo permite movimientos realistas de los osos.

Esta vez, simplemente usaremos todo un color de verde, pero creo que se volverá más realista si usa texturas y otras cosas.

// ==== // Parte 4: Configuración de tierra // ===== const Ground: react.fc = () => {return ( <mesh rotation={[-Math.PI / 2, 0, 0]} position={GROUND_POSITION}><planeGeometry args={[GROUND_SIZE, GROUND_SIZE, GROUND_SEGMENTS, GROUND_SEGMENTS]} /><meshStandardMaterial color={GROUND_COLOR} side={DoubleSide} /></mesh> ); };
  • Generación del suelo
    • Cree un plano con plangeometría en reaccione tres fibra
    • Establezca el ancho, la altura y el número de divisiones del plano utilizando constantes predefinidas.
  • La aparición del suelo
    • Use MeshStandardMaterial
    • El color del suelo se especifica como Ground_Color verde
  • Colocación
    • Para nivelar el plano, gírelo 90 grados con respecto al eje X.
    • Establezca la posición de tierra como tierra_posición nuevo vector3 (0, 0, 0)

Parte 5: Arreglo de piedra aleatoria

Coloque piedras de tamaño y posición aleatorios en el suelo para agregar una sensación natural a la escena. Todo el color verde era demasiado simple, por lo que al colocar al azar las piedras, creamos una escena más realista.

// ===== // Parte 5: disposición de piedra aleatoria // ===== const randomstones: react.fc = () => {// Generar cálculos en posiciones aleatorias y escalas en la primera representación de const [piedras] = useSestate () => {return intray.from ({longitud: Stone_Count}, () => {const x = Math.Random () / 2; <mesh key={`${x}-${z}`} position={[x, y, z]} scale={[scale, scale, scale]}><sphereGeometry args={[1, 8, 8]} /><meshStandardMaterial color="gray" /></mesh> ); }); return <> {piedras}</> ; };
  • Generación de piedra
    • Use el USestate de React
    • Los datos de colocación incluyen múltiples piedras con posiciones y escalas aleatorias.
  • Colocación aleatoria
    • Usando Math.Random generamos aleatoriamente las coordenadas X y Z
    • Establezca aleatoriamente la escala dentro de los rangos de Stone_Scale_min y Stone_Scale_Max
  • La aparición de la piedra
    • Use la esghereegeometría
    • MeshandardMaterial para reproducir la textura de la piedra.
  • Evite el redibujado
    • Usestate genera piedras y las arregla durante la primera representación.
    • El rendimiento se mejora manteniendo la misma disposición de piedra al volver a dibujar.

Parte 6: Componente principal

Integra los modelos de animación de tierra, piedras aleatorias y de oso y crea el componente principal que administra toda la escena. Además, implementa una UI (botón) Operation que permite a los usuarios cambiar entre reproducir y detener animaciones.

// ==== // Parte 6: Componente principal // ===== const ThredModelanimation: react.fc = () => {const [isPlaying, setIsplaying] = useState (false); devolver (<div className="canvas-container"> <button style={{ position: 'absolute', top: '10px', left: '10px', zIndex: 100 }} onClick={() =>setPlaying (! isplaying)}> {isPlaying? 'PAUSE ANIMATION': 'Play Animation'}</button> <Canvas camera={{ position: CAMERA_POSITION.toArray() }}><ambientLight intensity={AMBIENT_LIGHT_INTENSITY} /><pointLight position={POINT_LIGHT_POSITION.toArray()} intensity={POINT_LIGHT_INTENSITY} /><OrbitControls /> {/ * Pantalla de tierra */}<Ground /> {/ * Disposición de piedra aleatoria */}<RandomStones /> {/ * Configuración de color de fondo */}<color attach="background" args={[BACKGROUND_COLOR]} /> {/ * Modelo de animación */}<AnimatedFBXModel path="/models/cuddly_bear/Animation_Walking_withSkin.fbx" isPlaying={isPlaying} /></Canvas></div> ); }; Exportar triunfo de treedModelanimación;
  • Construyendo la escena
    • Dibuje una escena 3D completa usando el componente de lienzo de React Three Fiber
    • Coloque suelo , las piedras aleatorias y la animada FBXModel dentro del lienzo .
  • Configuración de luz y cámara
    • Agregue luz ambiental y luz para alegrar toda la escena .
    • Habilite las operaciones de la cámara utilizando OrbitControls de la biblioteca DREI
  • Operaciones de animación UI
    • Cree un botón alternar entre Play and Stop, y administre el de Playing con el gancho USEstate
    • Cambie dinámicamente la etiqueta del botón el estado de splaying

por último

Se han completado todos los pasos en el proyecto "Deje que los Bears caminen con React x tres.js". ¡Ahora puede experimentar la diversión de ejecutar modelos 3D generados usando la herramienta AI (Meshy) usando React y Three.js!

¡Use Meshy para ver varios modelos 3D!

📺 Mire la demostración en YouTube : puede verlo desde este enlace

Si le resulta útil este tutorial, suscríbase a nuestro canal de YouTube y dale una calificación alta.

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