Exportar simulación de tela desde el mezclador a una escena interactiva

Este tutorial camina creando una animación interactiva: comenzando con el mezclador diseñando un botón y simulando un órgano de tela que cae en la superficie y se establece en un suave rebote.

Después del pan de simulación de tela, la animación se exporta y se presenta al proyecto tres.js, donde se convierte en una escena interactiva que se puede reiniciar al hacer clic.

Al final, tendrá una animación que causó que los usuarios mezclaran física simulador en Blender con tres ancho. JS e interacción.

¡Vamos a sumergirnos!

Paso 1: cree un cubo y agregue sub -divisiones

Iniciar un nuevo proyecto: Abra el mezclador y elimine el cubo predeterminado (seleccione y presione X, luego confirme).
Agregar cubo: Haga clic en Shift + A> Network> Cube para crear un nuevo cubo.
Ingrese la posición de edición: Seleccione el cubo, luego presione la pestaña para cambiar a la posición de edición.
Divide el cuboPresione Ctrl + R para agregar un bucle, carne sobre el cubo y pasar la rueda del mouse para aumentar la cantidad de descuentos.
Solicitud de división: Con el cubo continúa determinándose en la posición del objeto, vaya a la placa de velocidad (icono de dolor) y haga clic en Modificador> Surface de subdivisión. Establezca los niveles en 2 o 3 para obtener un resultado más suave, luego haga clic en la aplicación.

Paso 2: Agregar física de tela y configuración de configuración

Seleccione el cuboAsegúrese de determinar el cubo helado en la posición del objeto.
Agregar física de tela: Vaya a la pestaña Física en la placa de propiedad. Haga clic en la tela para habilitar la simulación de tela.
Instale los bordes (opcionales): Si desea que partes del cubo se fijaran (por ejemplo, la parte superior), cambie a la posición de edición, seleccione los cabezales que desea instalar y regrese a la pestaña Física, debajo de la tela>, haga clic en un pin para configurar estos cabezales en un conjunto superior.
Establezca los maestros clave:
- Pasos de calidad: Establezca en 10-15 para la simulación más suave (los valores más altos aumentan la precisión pero ralentizan la cuenta).
- bloquearEstablezca aproximadamente 0.2-0.5 kg para una tela más ligera y más flexible.
- presiónBajo la presión de Fabric>, habilite y coloque un valor positivo (por ejemplo, 2-5) para simular la inflación. Esto hará que la tela se expandirá como si el aire lo estuviera empujando.
- durezaEstablezca la tensión y la presión (por ejemplo, 10-15) para controlar o perder la rigidez de la tela.
Prueba de simulaciónPresione la barra de distancia para ejecutar la animación y ver la tela. Modifique la configuración según sea necesario.

Paso 3: Agregue un plano de tierra con colisión

Crear un avión de tierra: Haga clic en Shift + A> Mesh> Plano. Expanda su rango presionando S y arrastrar (por ejemplo, expandirlo a 5-10x) para que sea necesario interactuar con la tela.
Poner el aviónMueva el plano debajo del cubo presionando G> Z> -5 (o establecido según sea necesario).
Tipo colisiónSeleccione el plano, vaya a la pestaña Física y haga clic en Colisión. Deje la configuración predeterminada.
SimulaciónPresione la distancia nuevamente para ver que la tela se amplía y se establece en el plano de tierra.

Paso 4: Control de materiales y texturas

Seleccione el cubo: En la posición del objeto, seleccione la tela (cubo).
Agregar material: Vaya a la pestaña Material, haga clic en Nuevo para crear y nombrar un material.
Establezca el mapa básico de color/UV: En la abertura primaria, elija un color en forma de tela (por ejemplo, rojo o azul) o conecte la textura de la imagen haciendo clic en el punto amarillo junto al color básico y eligiendo la textura de la imagen. Descargue un archivo de tela si tiene uno.
Establecer aspereza y especialización: Rugosidad en 0.1-0.3 para echar un vistazo suave.
Aplicar al suelo (opcional): Repita el proceso del plano, utilizando un material gris o apretado simple para el contraste.

Paso 5: Exportar como MDD y crear las teclas de la forma para tres.

Para usar la animación de la tela en el proyecto Three.js, exportaremos el simulador de física como el archivo MDD utilizando el componente adicional de Newtek MDD, luego volveremos a importarlo para crear las teclas de la forma. Sigue estos pasos:

Actualmente habilitando el programa Newtec MDD:
1. Vaya a Editar> Preferencias> Trabajos adicionales.
2. Busque “Newtek” o “MDD” y habilite “Exper-Export: Newtek MDD Format” revisando la caja. Cierre la ventana de preferencia.
Aplicar todas las tarifas y todas las conversiones:
1. En la posición del objeto, seleccione el objeto de tela.
2. Vaya a la placa de velocidad (el icono de la llave de fijación). Para cada tarifa (por ejemplo, superficie de subdivisión, tela), haga clic en Drop -down y seleccione la aplicación. Esto “congela” la red con su forma actual y datos físicos.
3. Asegúrese de que no haya deformidades no coincidentes (por ejemplo, escala): haga clic en Ctrl + A> todas las transferencias para aplicar el sitio, la rotación y la escala.
Exportar como MDD:
1. Con la definición de la tela, vaya a Archivo> Exportar> Lightwave Point (.mdd).
2. En la configuración de exportación (debajo de la izquierda):
  - Establezca el FPS (segundos) para adaptarse a su proyecto (por ejemplo, 24, 30 o 60).
  - Establezca el marco de inicio/finalización para la animación.
3. Elija un sitio Guardar (por ejemplo, “Inflación. MDD”) y haga clic en MDD Exportar.
Importación de MDD:
1. Vaya a Archivo> Importar> LightWave Point (.mdd) y descargue el archivo “UperationD.MD”.
2. En el panel de física y de velocidad, elimine las opciones relacionadas con la simulación de tela, donde ahora tenemos las claves para dar forma.

Paso 6: Exportar el objeto de simulación de tela en nombre de GLB

Después de importar MDD, seleccione el cubo con datos de animación.

Exportar como GLTF 2.0 (.Glb/.Gltf): Vaya a Archivo> Exportar> GLTF 2.0 (.GLB/.GLTF).
Revise las teclas para dar forma y animación
1. Dentro de la sección de datos, verifique las claves de la forma para incluir los objetivos de Movh creados a partir de la animación.
2. Verifique la animación para exportar datos de animación asociados con la forma de la forma.
Exportar: Elija un sitio de guardado (por ejemplo, “inflación. GLB”) y haga clic en Exportar GLTF 2.0. Este archivo ahora está listo para su uso en tres.js.

Paso 7: Implementación de la tela de animación en tres.js

En este paso, usaremos tres. JS con React (a través de react- tres/fibra) para descargar y estimular el efecto de la ampliación del archivo de inflación. GLB se exportó en el paso 6. A continuación se muestra el símbolo con interpretaciones:

Preparar importaciones y pista de archivos:
1. Importe las bibliotecas necesarias: tres para Core Three.js, Useref, Usestate, Use de React for State y Lifecycle Management, instalaciones de @React-Three/Fiber y @React-Three/Drei para proporcionar y controlar elementos.
2. Importe GLTFLOCER de tres.js para descargar el archivo .Glb.
3. Determine el curso de la forma: const modelPath = ‘/inflation.glb’; Se refiere al archivo que se exportó (ajuste la ruta en función de la estructura del proyecto).
Crear un componente de formulario:
1. Seleccione el componente de formulario para tratar con el archivo .Glb.
2. Use variables de estado: un modelo para un 3D, cargado para rastrear el progreso y el error al tratar los problemas.
3. Use Useref para almacenar los procedimientos de animación y los procedimientos de animación (ActiveRef) para controlar la operación.
Descargue el formulario con animación:
1. En UseeFfection, GLTFLoader se basa en la inflación.
2. Éxito (GLTF):
  - Gltf.scene y crear un fabricante animado.
  - Cada sección tiene una animación en gltf. Animaciones:
    - Seleccione el período a 6 segundos (Clip.Duration = 6).
    - Crea una animación (mezcler.clipction).
    - Clase: Clampwhenfinised = REAL STOP En el último cuadro, episodio = tres.looponce juega una vez e impone setduration (6) por un período de 6 segundos.
    - Restablecer y operar inmediatamente el procedimiento, almacenándolo en ActionRef.Current.
  - Actualice el estado con el formulario cargado y ajuste la descarga en un error.
3. Registre la aplicación con la llamada XHR.
4. Lidiar con errores en el contacto de error y actualizar el error.
5. Limpie la batidora en el ingrediente poco atractivo.
Mover el formulario:
1. Use USFRAME para actualizar el mezclador cada cuadro usando mezclerRef.current.upate (delta), que desarrolla la animación a tiempo.
2. Agregue la reacción:
  - HandLeclic: restablecer y restaurar toda la animación para hacer clic.
  - OnpoinTerover/OnPoinTerout: Cambiar el indicador para indicar clic.
Hacer:
1. Retorno vacío Si todavía está cargado, se produce un error o no se carga ningún modelo.
2. Devolver un Un componente con un modelo cargado, habilitando tonos y asociado con eventos.
Crear un piso reflectante:
1. Definición de metalground como red con ingeniería de aeronaves (args = {[100, 100]}).
2. Aplique MeshreflectoryMate con propiedades como metales = 0.5, rugosidad = 0.2 y color = “#202020” para una apariencia de metal y reflectante. Establezca el camuflaje, la fuerza y la precisión según sea necesario.
Preparar la escena:
1. En el componente de la aplicación, cree un
2. Agregar instrucciones a [0, 15, 0] Con el empoderamiento de los tonos.
3. Antes del entorno (“estudio”) para la iluminación, un modelo en [0, 5, 0]ContactShadows para realismo, rotación de minerales y lugar a continuación.
4. Agregue StatEControls al movimiento interactivo de la cámara.

import * as THREE from 'three';
import { useRef, useState, useEffect } from 'react';
import { Canvas, useFrame } from '@react-three/fiber';
import { OrbitControls, Environment, MeshReflectorMaterial, ContactShadows } from '@react-three/drei';
import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';

const modelPath = '/inflation.glb';

function Model({ ...props }) {
  const [model, setModel] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);
  const mixerRef = useRef(null);
  const actionsRef = useRef([]);

  const handleClick = () => {
    actionsRef.current.forEach((action) => {
      action.reset();
      action.play();
    });
  };

  const onPointerOver = () => {
    document.body.style.cursor = 'pointer';
  };

  const onPointerOut = () => {
    document.body.style.cursor = 'auto';
  };

  useEffect(() => {
    const loader = new GLTFLoader();
    const dracoLoader = new DRACOLoader();
    dracoLoader.setDecoderPath('https://www.gstatic.com/draco/v1/decoders/');
    loader.setDRACOLoader(dracoLoader);

    loader.load(
      modelPath,
      (gltf) => {
        const mesh = gltf.scene;
        const mixer = new THREE.AnimationMixer(mesh);
        mixerRef.current = mixer;

        if (gltf.animations && gltf.animations.length) {
          gltf.animations.forEach((clip) => {
            clip.duration = 6;
            const action = mixer.clipAction(clip);
            action.clampWhenFinished = true;
            action.loop = THREE.LoopOnce;
            action.setDuration(6);
            action.reset();
            action.play();
            actionsRef.current.push(action);
          });
        }

        setModel(mesh);
        setLoading(false);
      },
      (xhr) => {
        console.log(`Loading: ${(xhr.loaded / xhr.total) * 100}%`);
      },
      (error) => {
        console.error('An error happened loading the model:', error);
        setError(error);
        setLoading(false);
      }
    );

    return () => {
      if (mixerRef.current) {
        mixerRef.current.stopAllAction();
      }
    };
  }, []);

  useFrame((_, delta) => {
    if (mixerRef.current) {
      mixerRef.current.update(delta);
    }
  });

  if (loading || error || !model) {
    return null;
  }

  return (
    
  );
}

function MetalGround({ ...props }) {
  return (
    
      
      
    
  );
}

export default function App() {
  return (
    
  );
}

¡Y eso es todo! Comenzando con la simulación de tela más audaz, lo convertimos en un botón que cae en su lugar e interactúa con un poco de rebote dentro de la escena de tres.js.

Este flujo de trabajo muestra cómo las operaciones de simulación de física de Blender pueden exportarse e integrarse con tres.js para crear experiencias interactivas en el tiempo real en la web.

Source link