Contrôler les modèles 3D au format GLB généré à l'aide de Meshy AI en utilisant React et Three.js! Comment gérer plusieurs animations

Contrôler les modèles 3D au format GLB généré à l'aide de Meshy AI en utilisant React et Three.js! Comment gérer plusieurs animations

Êtes-vous intéressé à contrôler les animations pour les modèles 3D? Récemment, il existe un nombre croissant d'outils de génération de modèles 3D qui utilisent l'IA, et parmi eux Meshy IA attire l'attention en tant qu'outil qui vous permet de créer facilement des modèles 3D de haute qualité.

Cependant, afin d'utiliser les modèles 3D générés dans des applications réelles, vous devez maîtriser des bibliothèques et des outils spécifiques. Dans cet article, nous expliquerons comment utiliser React et Three.js

📺 Vérifiez le maillage : vous pouvez le vérifier sur la page officielle à partir de ce lien

Cette fois, la version pro (environ 3 000 yens par mois) est requise. (L'animation est uniquement disponible en version pro)

Nous continuerons à créer des leçons et travaillent à partir de TypeScript X React Three Fibre à l'avenir!
Nous ferons une annonce sur YouTube, alors veuillez vous abonner à notre chaîne YouTube et attendre les notifications!

📺 Regardez YouTube : vous pouvez le regarder à partir de ce lien

Si vous souhaitez savoir ce que React Three Fibre peut faire, veuillez vous référer à ce qui suit!
Nous avons des travaux faciles à utiliser disponibles!

table des matières

Demo d'affichage du modèle 3D

Vous pouvez voir la démo du produit fini dans la vidéo ci-dessous.

📺 Regardez la démo sur YouTube : vous pouvez le regarder à partir de ce lien

De plus, le code source de ce projet est disponible sur GitHub.
Veuillez télécharger le code et l'essayer!

💾 Référentiel GitHub : vérifiez le code source de ce lien

Si vous vous demandez: "Je l'ai vu, comment puis-je le faire?", Ne vous inquiétez pas!
Dans cet article, nous expliquerons étape par étape comment voir ce modèle 3D.

Techniques nécessaires et bibliothèque clé

Ce projet utilise les technologies et les bibliothèques suivantes: voici une brève explication de chaque rôle.

  • Réagir
    • Bibliothèque pour le développement frontal
    • Construction efficace de l'interface utilisateur avec conception basée sur les composants
  • Trois.js
    • Une bibliothèque pour dessiner des graphiques 3D sur le Web
    • Il est facile de gérer les opérations Webgl complexes
  • Réagir trois fibres
    • Bibliothèque de wrapper pour gérer trois.js en réaction
    • Vous pouvez profiter des caractéristiques puissantes de trois.js dans le style de développement React
  • Réagir t'en drei
    • React Three Fibre Extension Library
    • React Three Fibre Extension Library
  • Maillé
    • Un service qui vous permet de générer facilement des modèles 3D de haute qualité en utilisant l'IA

Préparation environnementale

Cette section fournit la configuration initiale de votre projet. Créez une application React à l'aide de la commande NPX, installez les bibliothèques requises et organisez la structure du dossier.

Création d'une application React

Tout d'abord, créez une application React à l'aide de la commande NPX.

NPX CREATE-REACT-APP MESHY-3D-MODEL-ANIMation - Template TypeScript
  • Meshy-3D-Model-Animathion est le nom du projet
  • - Template Utilisez un modèle compatible TypeScript en spécifiant

Installation des bibliothèques requises

Installez React Three Fibre et d'autres bibliothèques.

CD Meshy-3D-Model-Animathion NPM Installer trois @ React-Three / Fiber @ React-Three / Drei
  • trois : trois.js corps principal
  • @ React-Three / Fibre : un emballage pour utiliser trois.js avec React
  • @ React-Three / Drei : Aiders utiles tels que les contrôles de la caméra et le dessin de texte

Examiner la structure des dossiers et supprimer des fichiers inutiles

Organisez et ajoutez des dossiers de l'état initial comme suit:
Fondamentalement, c'est la valeur par défaut, mais pour les fichiers que vous ne connaissez pas, veuillez consulter GitHub.

Meshy-3d-model-animation / ├── node_modules / ├── Modèles publiques / ├fique // // modèles 3D et fichiers connexes ├séLa_Glb / // Folder des modèles 3D ├── Animation_gangnam_groove_withskin.glb // fichiers GLB avec animation de danse ├fique Animation_pod_baby_groove_withskin.glb // fichiers glb avec animation de danse ├fique ├── THREEDDANCHINGUNCLE / // Dossier Page-by-Page │ │ └── ThreeddancingUcle.TSX // Pages d'animation 3D │ │ └── Index.ts // Fichier d'index pour les pages d'exportation │ ├fique ├fiques index.css // Global CSS ├fique

Les fichiers à modifier cette fois sont les suivants:

  • App.tsx : points d'entrée de l'application
  • Pages> index.ts : Index Fichier pour exporter la page vers.
  • pages / threeddancinguncle: Le dossier à créer cette fois
    • Threeddancinguncle.tsx : composant de la page principale.

Générer des modèles 3D avec meshy

Cette fois, le modèle 3D utilisera un service de génération automatique d'IA appelée Meshy.
Le lien est ci-dessous, veuillez donc vous y référer.

200 crédits par mois sont disponibles gratuitement.

📺 Vérifiez le maillage : vous pouvez le vérifier sur la page officielle à partir de ce lien

Cette fois, la version pro (environ 3 000 yens par mois) est requise. (L'animation est uniquement disponible en version pro)

Générer des modèles 3D avec des modèles de génération de texte

Cette fois, nous générerons un modèle avec du texte.
Veuillez sélectionner "nouveau modèle".

Je voulais que mon homme danse, alors j'ai décidé de "tout le corps d'un vrai détective d'âge moyen avec ses bras répandus".
Après cela, vous devrez installer vos articulations et autres choses, il est donc préférable de garder vos bras autant que possible de votre corps.

Cette fois, j'essaierai d'utiliser le haut à gauche.
Sélectionnez et sélectionnez Vérifiez la texture et le rehyme.

Cela générera un modèle similaire au modèle que vous avez sélectionné.

Ensuite, sélectionnez Animer> Rigging pour ajouter l'animation.

Cette fois, puisque nous sommes humains, nous devons choisir des humanoïdes.

Je ne pense pas qu'il soit nécessaire de changer l'écran suivant, mais j'ai un peu gâché avec ma taille.

Si vous définissez bien cela, l'animation sera belle.
Une fois que vous avez configuré les joints, vérifiez-le.

Cela générera un modèle 3D animé.
Par défaut, il y a une animation de marche.

Ajout d'animations

Cette fois, nous ajouterons plusieurs animations de danse.

Ajoutez plusieurs danses de votre choix à l'aide du bouton Ajouter.

Par défaut, l'exécution est incluse, mais vous pouvez voir qu'il existe trois autres danses en plus de cela.

Télécharger au format GLB

Une fois que vous avez créé un modèle 3D et ajouté des animations, téléchargez-la à l'aide de GLB.
Pour le moment, vérifiez toutes les animations.

Cela sortira un fichier GLB pour chaque animation comme indiqué ci-dessous.
Le fichier GLB est livré avec un ensemble de modèles 3D et d'animations, donc le fichier de modèle n'existe pas.

Assurez-vous de stocker des fichiers GLB sous public.
Cette fois, il est stocké ci-dessous.

Meshy-3d-model-animation / ├── node_modules / └── Modèles publiques / └fique // // modèles 3D et fichiers connexes └séLa_Glb / // Folder des modèles 3D ├── Animation_gangnam_groove_withskin.glb // fichiers GLB avec animation de danse ├fique Animation_pod_baby_groove_withskin.glb // fichiers glb avec animation de danse └sémer

Explication détaillée du code source pour chaque étape

Dans les sections suivantes, nous expliquerons en détail les cinq parties ci-dessous dans l'ordre.

PARTIE
PARTIE
Importation des modules requis
  • Importez des modules de base pour React et Three.js.
  • Importez GLTFLoader et ExrLoader
  • Utilisez OrbitControls
PARTIE
Définitions constantes
  • Données constantes .
  • Définissez ce qui suit:
    • Liste des fichiers d'animation : conserve les noms et chemins de chemin de plusieurs fichiers d'animation dans un format de liste.
    • Par défaut de la caméra : définit la position de la caméra afin que vous puissiez voir l'ensemble du modèle.
    • Paramètres d'éclairage : Réglez l'intensité et la position de la lumière ambiante, de la lumière directionnelle et de la lumière ponctuelle.
    • Chemin d'arrière-plan HDRI : spécifiez le fichier d'image HDRI pour l'arrière-plan.
PARTIE
Paramètres d'arrière-plan
  • Chargez des images HDRI à l'aide d'Exrloader
  • Appliquez le HDRI chargé comme suit:
    • Scene.Background : Définissez une image HDRI à l'arrière-plan de toute la scène.
    • Scene.environment : HDRI est utilisé pour la réflexion et l'éclairage du modèle.
PARTIE
Modèles et animations
  • Gltfloader Chargez le modèle en utilisant
    • Chargez l'animation initiale ( default_animation_file
    • Échelle, tourner et positionner le modèle importé et le placer dans la scène
  • AnimationMixer Utiliser pour gérer les animations
    • Appliquer l'animation aux modèles importés
    • L'animation en cours de lecture l'état de React ( USESTATE ) et Switchable à l'aide des opérations utilisateur.
  • Utiliser useFrame
PARTIE
Composants principaux
  • Configuration de l'application entière avec React
  • Dessinez les éléments suivants en toile
    • Composant de fond
    • Modèles et animations ( du modèle )
    • Lumières (lumière ambiante, lumière directionnelle, lumière ponctuelle)
  • Placer le bouton de basculement d'animation
    • Appuyez sur le bouton passer au fichier d'animation spécifié.

Vérifiez toute la source

ci-dessous le code source complet qui contrôle le modèle 3D au format GLB généré à l'aide de Meshy AI, qui est créé dans cet article, en utilisant React et Three.js Tout le code est mis en place, il est donc facile d'avoir une idée de son fonctionnement.

Si vous souhaitez voir d'autres sources, veuillez consulter GitHub.

💾 Référentiel GitHub : vérifiez le code source de ce lien

import './app.css'; import {threeddancinguncle} de './pages'; fonction app () {return (<div className="App"><ThreeDDancingUncle /></div> )); } Exporter l'application par défaut;
import threeddancinguncle de "./threeddancinguncle/threeddancinguncle"; export {threeddancinguncle}
// ==== // Partie 1: Importez les modules requis // ==== Importer React, {UseState, UseEffected} de "React"; import {canvas, useFrame, useThree} de "@ react-trois / fibre"; import {orbitControls} de "@ react-trois / drei"; import {gltfloader} à partir de "trois / exemples / jsm / chargeurs / gltfloader"; import {exrloader} à partir de "trois / exemples / jsm / chargeurs / exrloadher"; import * comme trois de "trois"; // ==== // Partie 2: Définir les constantes // ==== // Liste des fichiers d'animation // Stockez le nom et le chemin de chaque animation Const Animation_files = [{name: "pod baby groove", chemin: "/models/uncle_glb/animation_pod_baby_groove_withskin.glb"}, {name: "gangny", path :glb "}, {name:" gangny ", path :glb"}, {name: "Gangny", Pathskin " "/models/uncle_glb/animation_gangnam_groove_withskin.glb"}, {name: "pop danse", chemin: "/models/uncle_glb/animation_superlove_pop_dance_withskin.glb"},]; // Chemin vers le modèle de modèle const default_animation_file = animation_files [0] .path; // Chemin d'image HDRI (pour l'arrière-plan) const hdri_file = "/hdri/cobblestone_street_night_4k.exr"; // Position initiale de la caméra (x, y, z) const initial_camera_position = new Three.vector3 (10, 4, 10); // Modèle de grossissement de l'échelle const Model_Scale = 4; // Angle de rotation du modèle initial (à propos de l'axe y, dans Radians) const Model_Rotation_y = -1; // Position du modèle initial (x, y, z) const Model_Position = new Three.vector3 (0, -2, 0); // Paramètres lumineux // Définir la position et l'intensité de la lumière et de l'intensité de la lumière ponctuelle et de la direction 0), intensité: 1,5}, // la position et l'intensité de la lumière ponctuelle}; // ===== // Partie 3: Paramètres d'arrière-plan // ===== // Définissez l'arrière-plan de la scène avec HDRI Image const Background: react.fc = () => {const {gl, scage} = usethree (); useEffect (() => {const hdrloader = new ExrLoader (); const pmremGenerator = new Three.PmRemGenerator (GL); pmremGenerator ........ pmremGenerator.fromequirectangular (texture) .Texture; retourner null; // pas de rendu cible}; // ==== // Partie 4: Modèles et animations // === // Chargement du modèle principal et gestion de l'animation CONS Modèle: react.fc <{CurrentAranimation: String}> = ({currentArAnimation}) => {const {caméra} = useThree (); const [modèle, setModel] = UseState<THREE.Group | null> (nul); const [mélangeur, setMixer] = Usestate<THREE.AnimationMixer | null> (nul); // Charger le modèle useEffecte (() => {const Loader = new Gltfloader (); Loader.Load (default_animation_file, (Gltf) => {const {Scene: LoadEdScene} = Gltf; LoadEdScene.Scale.Set (Model_Scale, Model_Scale, Model_SCale); // Définir la rotation initiale du modèle Loadscène.Position.copie (Model_Position); 0); // Toggle Animation UseEFFECT (() => {if (! Model ||! Mixer) return; const loder = new GlTFOLODOFer (); Loder.Load (CurrentAnimation, (Gltf) => {const NewAnimation = Gltf.animations [0]; if (newanimation) {Constopall (stopage.clipaction (newanimation); mixer. Action.Reset (). Fadein (0,5) .Play (); // Mise à jour de l'animation useframe ((_, delta) => {if (mixer) mixer.update (delta);}); modèle de retour?<primitive object={model} /> : nul; // montre le modèle}; // ==== // Partie 5: Composants principaux // ==== // Configuration de l'application entière const threeddancinguncle: react.fc = () => {const [currentAranimation, setCurrentAnimation] = useState (animation_files [0] .Path); retour (<div style={{ width: "100vw", height: "100vh", position: "relative" }}> {/ * Bouton de sélection d'animation * /} <div style={{ position: "absolute", top: "10px", left: "10px", zIndex: 10, // ボタンをCanvasの上に表示 }} > {Animation_files.map ((Anim, index) => ( <button key={index} onClick={() =>setCurrentAnimation (Anim.path)} // Toggle Animation Style = {{margin: "5px", padding: "10px", Fontsize: "14px", arrière "5px", curseur: "pointeur",}}> {anim.name}</button> ))}</div><Canvas> {/ * Composant d'arrière-plan * /}<Background /> {/ * Modèles et animations * /}<Model currentAnimation={currentAnimation} /> {/ * Paramètres légers * /} <ambientLight intensity={LIGHT_SETTINGS.ambient.intensity} /><directionalLight position={LIGHT_SETTINGS.directional.position} intensity={LIGHT_SETTINGS.directional.intensity} /><pointLight position={LIGHT_SETTINGS.point.position} intensity={LIGHT_SETTINGS.point.intensity} /> {/ * Fonctionnement de la caméra * /}<OrbitControls /></Canvas></div> )); }; Exporter par défaut Threeddancinguncle;

Partie 1: Importation de modules requis

Cela préparera les modules nécessaires pour construire une scène 3D en utilisant React et Three.js.

// ==== // Partie 1: Importez les modules requis // ==== Importer React, {UseState, UseEffected} de "React"; import {canvas, useFrame, useThree} de "@ react-trois / fibre"; import {orbitControls} de "@ react-trois / drei"; import {gltfloader} à partir de "trois / exemples / jsm / chargeurs / gltfloader"; import {exrloader} à partir de "trois / exemples / jsm / chargeurs / exrloadher"; import * comme trois de "trois";
  • Réagir
    • UseState : changez d'animations et gérez l'état.
    • Utiliser EFFECT : s'exécute lors de l'initialisation d'un modèle ou d'un arrière-plan.
  • Réagir trois fibres
    • Canvas : un conteneur pour dessiner des scènes 3D.
    • UseFrame : effectue un traitement de mise à jour d'animation pour chaque trame.
    • USETHREE : Accès aux caméras, scènes et rendements en trois.js.
  • @ React-Three / Drei
    • OrbitControls : un composant pratique qui permet à l'utilisateur de contrôler librement (tourner, zoomer, déplacer) l'appareil photo.
  • Trois.js
    • Gltfloader : chargeur pour le chargement des modèles 3D au format GLB.
    • ExrLoader : charge des images HDRI et les utilise comme arrière-plan et lumière ambiante.
    • Three.Vector3 : Fonctionnement du vecteur (par exemple, caméra ou position de lumière).
    • Three.PmreMGenerator : convertit HDRI comme une carte environnementale pour obtenir un éclairage réaliste.

Partie 2: Définition constante

Ensuite, la définition constante.
La définition des constantes gère centralement les valeurs utilisées dans votre application, améliorant la réutilisabilité et la lisibilité. Étant donné que la définition des valeurs pour les modèles 3D et les scènes sont utilisées partout dans le code, ce qui les rend plus faciles à entretenir.

// ==== // Partie 2: Définir les constantes // ==== // Liste des fichiers d'animation // Stockez le nom et le chemin de chaque animation Const Animation_files = [{name: "pod baby groove", chemin: "/models/uncle_glb/animation_pod_baby_groove_withskin.glb"}, {name: "gangny", path :glb "}, {name:" gangny ", path :glb"}, {name: "Gangny", Pathskin " "/models/uncle_glb/animation_gangnam_groove_withskin.glb"}, {name: "pop danse", chemin: "/models/uncle_glb/animation_superlove_pop_dance_withskin.glb"},]; // Chemin vers le fichier modèle const default_animation_file = Animation_Files [0] .path; // Chemin vers l'image HDRI (pour l'arrière-plan) const hdri_file = "/hdri/cobblestone_street_night_4k.exr"; // Position initiale de la caméra (x, y, z) const initial_camera_position = new Three.vector3 (10, 4, 10); // Modèle de grossissement de l'échelle const Model_Scale = 4; // angle de rotation initial du modèle (autour de l'axe y, dans les radians) const Model_Rotation_y = -1; // Position initiale du modèle (x, y, z) const Model_Position = new Three.vector3 (0, -2, 0); // Paramètres lumineux // Définir la position et l'intensité de la lumière ambiante, directionnelle et ponctuelle const Light_settings = {ambient: {l'intensité: 0,5}, // Intensité de lumière ambiante Direction: {position: new Three.Vector3 (10, 20, 10), Intensity: 1,5}, // / la position et l'intensité du point de lumière directionnelle: {position: Position: Nouveau. 0), intensité: 1,5}, // la position et l'intensité de la lumière ponctuelle};

Selon le modèle 3D que vous générez, des ajustements fins peuvent être nécessaires, veuillez donc utiliser ce qui suit comme référence pour jouer avec les nombres.

  • Liste des fichiers d'animation
    • Définissez les noms et les chemins d'animation par paires pour gérer plusieurs animations.
  • Chemin d'image HDRI pour l'arrière-plan
    • Spécifiez le chemin d'accès à l'image HDRI à utiliser comme arrière-plan de la scène ou de la carte environnementale.
  • Paramètres initiaux de la caméra
    • Définissez la position initiale et l'orientation de la caméra et ajustez l'intégralité du modèle pour le rendre approprié.
  • Paramètres du modèle
    • Définit l'échelle (magnitude), l'angle de rotation et la position initiale du modèle.
  • Paramètres légers
    • Définissez la position et l'intensité des lumières ambiantes, directionnelles et ponctuelles pour éclairer correctement toute la scène.

Partie 3: Paramètres d'arrière-plan

Utilisez des images HDRI pour appliquer des arrière-plans réalistes et naturels et une lumière ambiante à votre scène.
Les images HDRI peuvent être téléchargées gratuitement à partir de Poly Haven Vous devez choisir votre parcours préféré.

// ==== // Partie 3: Définition de l'arrière-plan // ==== // Définissez l'arrière-plan de la scène avec HDRI Image const Background: react.fc = () => {const {gl, scage} = usethree (); useEffect (() => {const hdrloader = new ExrLoader (); const pmremGenerator = new Three.PmRemGenerator (GL); pmremGenerator ........ pmremGenerator.fromequirectangular (texture) .Texture; retourner null; // pas de rendu cible};
  • Chargement des images HDRI
    • Chargez des images HDRI à l'aide d'Exrloader
    • Convertissez HDRI en cartes d'environnement à l'aide de PmreMGenerator
  • Appliquer des arrière-plans
    • l'image HDRI chargée comme fond de scène ( Scene.Background ).
    • carte environnementale ( scène.environment ) et utilisé pour les modèles de réflexion et d'éclairage.
  • Gestion de la mémoire
    • Après avoir appliqué des images HDRI sur la scène, libérez correctement des ressources inutiles (textures et générateurs).

Partie 4: réglage du sol

Charge les modèles 3D dans la scène, vous permettant de contrôler et de basculer plusieurs animations.
L'animation est mise à jour en douceur pour chaque trame, permettant des mouvements en temps réel.

// ==== // Partie 4: Modèles et animation // ==== // Chargement du modèle principal et gestion de l'animation CONS Modèle: react.fc <{CurrentAranimation: String}> = ({currentArAnimation}) => {const {caméra} = useThree (); const [modèle, setModel] = UseState<THREE.Group | null> (nul); const [mélangeur, setMixer] = Usestate<THREE.AnimationMixer | null> (nul); // Charger le modèle useEffecte (() => {const Loader = new Gltfloader (); Loader.Load (default_animation_file, (Gltf) => {const {Scene: LoadEdScene} = Gltf; LoadEdScene.Scale.Set (Model_Scale, Model_Scale, Model_SCale); // Définir la rotation initiale du modèle Loadscène.Position.copie (Model_Position); 0); // Toggle Animation UseEFFECT (() => {if (! Model ||! Mixer) return; const loder = new GlTFOLODOFer (); Loder.Load (CurrentAnimation, (Gltf) => {const NewAnimation = Gltf.animations [0]; if (newanimation) {Constopall (stopage.clipaction (newanimation); mixer. Action.Reset (). Fadein (0,5) .Play (); // Mise à jour de l'animation useframe ((_, delta) => {if (mixer) mixer.update (delta);}); modèle de retour?<primitive object={model} /> : nul; // Affichage du modèle};
  • Chargement du modèle
    • Chargez un modèle 3D au format GLB à l'aide de GLTFLoader
    • Réglez l'échelle, la position et la rotation du modèle de manière appropriée et ajoutez-la à la scène.
  • Gestion des animations
    • L'animation est appliquée au modèle à l'aide d'AnimationMixer
    • Une fonction de commutation d'animation a été implémentée en fonction des opérations utilisateur.
  • Mises à jour cadre par trame
    • Utilisez useFrame
    • Progrès en douceur à travers l'animation basée sur le temps écoulé (Delta).
  • Gestion du statut
    • Utilisez UseState de React
    • Reflète des animations sélectionnées par l'utilisateur en temps réel.

Partie 5: composant principal

Utilisez React pour configurer l'ensemble de l'application et intégrer chaque fonctionnalité (arrière-plan, modèle, animation, paramètres légers).
Nous énumérons également les UIS à opération utilisateur (tels que les boutons de commutation d'animation) ici.

// ==== // Partie 5: Composant principal // ==== // Configuration de l'application entière const threeddancinguncle: react.fc = () => {const [currentAnimation, setCurrentanimation] = useState (animation_files [0] .Path); retour (<div style={{ width: "100vw", height: "100vh", position: "relative" }}> {/ * Bouton de sélection d'animation * /} <div style={{ position: "absolute", top: "10px", left: "10px", zIndex: 10, // ボタンをCanvasの上に表示 }} > {Animation_files.map ((Anim, index) => ( <button key={index} onClick={() =>setCurrentAnimation (Anim.path)} // Toggle Animation Style = {{margin: "5px", padding: "10px", Fontsize: "14px", arrière "5px", curseur: "pointeur",}}> {anim.name}</button> ))}</div><Canvas> {/ * Composant d'arrière-plan * /}<Background /> {/ * Modèles et animations * /}<Model currentAnimation={currentAnimation} /> {/ * Paramètres légers * /} <ambientLight intensity={LIGHT_SETTINGS.ambient.intensity} /><directionalLight position={LIGHT_SETTINGS.directional.position} intensity={LIGHT_SETTINGS.directional.intensity} /><pointLight position={LIGHT_SETTINGS.point.position} intensity={LIGHT_SETTINGS.point.intensity} /> {/ * Fonctionnement de la caméra * /}<OrbitControls /></Canvas></div> )); }; Exporter par défaut Threeddancinguncle;
  • Installation de toile
    • Créez un cadre pour dessiner une scène 3D à l'aide du composant Canvas
  • Intégration de chaque fonctionnalité
    • Ajoutez un arrière-plan ( le composant d'arrière-plan
    • Dessinez des modèles et des animations ( du modèle
    • Les réglages lumineux (lumière ambiante, lumière directionnelle, lumière ponctuelle) sont placées dans la scène.
  • Placement de l'interface utilisateur
    • Implémente un bouton qui bascule les animations sélectionnées par l'utilisateur à l'aide de la gestion de l'état de React ( USESTATE
    • L'interface utilisateur est la toile , ce qui en fait un design facile à utiliser.
  • Action utilisateur
    • Vous pouvez changer d'animations à l'aide des boutons et lire l'animation sélectionnée en temps réel.

dernièrement

Toutes les étapes de "Contrôle des modèles 3D au format GLB généré avec Meshy AI en utilisant React et Three.js" ont été terminées. Vous pouvez maintenant vivre le plaisir de faire fonctionner des modèles 3D générés à l'aide d'outil AI (Meshy) en utilisant React et Three.js!

Utilisez Meshy pour voir divers modèles 3D!

📺 Regardez la démo sur YouTube : vous pouvez le regarder à partir de ce lien

Si vous avez trouvé ce tutoriel utile, veuillez vous abonner à notre chaîne YouTube et lui donner une note élevée!

De plus, le code source de ce projet est disponible sur GitHub.
Veuillez télécharger le code et l'essayer!

💾 Référentiel GitHub : vérifiez le code source de ce lien

Si vous avez trouvé cela utile, veuillez vous abonner à notre chaîne!

Nous continuerons à créer des leçons et travaillent à partir de TypeScript X React Three Fibre à l'avenir!
Nous ferons une annonce sur YouTube, alors veuillez vous abonner à notre chaîne YouTube et attendre les notifications!

📺 Regardez YouTube : vous pouvez le regarder à partir de ce lien

Si vous souhaitez savoir ce que React Three Fibre peut faire, veuillez vous référer à ce qui suit!
Nous avons des travaux faciles à utiliser disponibles!

Partagez si vous le souhaitez!

Qui a écrit cet article

Ceci est un blog que j'ai commencé à étudier la sécurité de l'information. En tant que nouvel employé, je serais heureux si vous pouviez regarder avec un cœur large.
Il y a aussi Teech Lab, qui est l'occasion d'étudier le plaisir en programmation, donc si vous êtes intéressé par le développement de logiciels, assurez-vous de jeter un œil!

table des matières