morfeo 0.1.2 → 0.1.3

package/index.d.ts

@@ -77,7 +77,7 @@ export type Capa = CapaBase &
 		| {tipo: 'marca'; tam?: number}
 		| {tipo: 'particulas'; particulas?: 'burbujas' | 'polvo' | 'estrellas' | 'nieve' | 'confeti'; cantidad?: number; color?: string}
 		| {tipo: 'grupo'; capas?: Capa[]; capa?: Capa; repetir?: number; disposicion?: 'circulo' | 'fila' | 'columna' | 'cuadricula' | 'pila' | 'aleatorio'; radio?: number; espacio?: number; espacioV?: number; columnas?: number; orientar?: boolean | number; retraso?: number; area?: [number, number]; girarAzar?: number; desorden?: number}
-		| {tipo: 'modelo'; src?: string; forma?: 'moneda' | 'billete' | 'cubo' | 'esfera' | 'lingote' | Objeto3D; color?: string; metal?: number; rugosidad?: number; ancho?: number; alto?: number; tamano?: number; rotacion?: [number, number, number]; girar3d?: [number, number, number]; cantidad?: number; crecer?: boolean; duracion?: number; distancia?: number; camaraY?: number; luz?: number; reflejos?: number; /** tuberia */ puntos?: [number, number, number][]; radio?: number; material?: 'pvc' | 'cobre' | 'acero' | 'vidrio'; agua?: boolean; velocidad?: number; colorAgua?: string; gotas?: number; /** muro */ columnas?: number; filas?: number; colorLadrillo?: string; colorMezcla?: string; /** viga */ largo?: number; vertical?: boolean; /** escalera */ escalones?: number; /** suelo */ capas?: [string, number][]}
+		| {tipo: 'modelo'; src?: string; forma?: 'moneda' | 'billete' | 'cubo' | 'esfera' | 'lingote' | Objeto3D; color?: string; metal?: number; rugosidad?: number; ancho?: number; alto?: number; tamano?: number; rotacion?: [number, number, number]; girar3d?: [number, number, number]; cantidad?: number; crecer?: boolean; duracion?: number; distancia?: number; camaraY?: number; luz?: number; reflejos?: number; /** levanta hacia la cámara los modelos planos acostados (por defecto en recursos) */ levantar?: boolean; /** tuberia */ puntos?: [number, number, number][]; radio?: number; material?: 'pvc' | 'cobre' | 'acero' | 'vidrio'; agua?: boolean; velocidad?: number; colorAgua?: string; gotas?: number; /** muro */ columnas?: number; filas?: number; colorLadrillo?: string; colorMezcla?: string; /** viga */ largo?: number; vertical?: boolean; /** escalera */ escalones?: number; /** suelo */ capas?: [string, number][]}
 		| {tipo: 'componente'; nombre: string; props?: Record<string, unknown>}
 		| {tipo: 'personaje'; nombre: string; pose?: string; poses?: {en: Momento; pose: string}[]; hablar?: boolean; ancho?: number}
 		| {tipo: 'escena3d'; src: string; camara?: {en?: Momento; pos: [number, number, number]; mirar?: [number, number, number]; fov?: number}[]; animacion?: boolean | string | string[]; velocidad?: number; mostrar?: {nodo: string; en: Momento}[]; ocultar?: {nodo: string; en: Momento}[]; fondo?: string | null; niebla?: [number, number]; luz?: number; luzAmbiente?: number; sol?: [number, number, number]; reflejos?: number; sombras?: boolean; ancho?: number; alto?: number}
@@ -90,7 +90,7 @@ export type Capa = CapaBase &
 		| {tipo: 'onda'; barras?: number; ancho?: number; alto?: number; color?: string; siempre?: boolean}
 		| {tipo: 'globo'; texto: string; cola?: 'abajo' | 'arriba' | 'izq' | 'der' | 'ninguna'; fondo?: string; color?: string; borde?: string; tam?: number; maxAncho?: number}
 		| {tipo: 'seguir'; usuario?: string; texto?: string; pulsar?: number}
-		| {tipo: 'recurso'; buscar: string; estilo?: '2d' | '3d' | 'realista'; variante?: 'color' | 'clay' | 'glass' | 'kawaii' | 'retro' | 'pastel' | 'sticker' | 'skeuo' | 'plush' | 'anime' | 'luxe' | 'chrome' | 'liquid' | 'bauhaus' | 'brutal' | 'gothic' | 'linea'; fuente?: 'kenney' | 'polyhaven' | 'iconify' | 'polypizza'; indice?: number; color?: string; ancho?: number; alto?: number; girar3d?: [number, number, number]; rotacion?: [number, number, number]}
+		| {tipo: 'recurso'; buscar: string; estilo?: '2d' | '3d' | 'realista'; variante?: 'color' | 'clay' | 'glass' | 'kawaii' | 'retro' | 'pastel' | 'sticker' | 'skeuo' | 'plush' | 'anime' | 'luxe' | 'chrome' | 'liquid' | 'bauhaus' | 'brutal' | 'gothic' | 'linea' | 'plano'; fuente?: 'kenney' | 'polyhaven' | 'iconify' | 'polypizza'; indice?: number; color?: string; ancho?: number; alto?: number; girar3d?: [number, number, number]; rotacion?: [number, number, number]}
 		| {tipo: 'escenario'; nombre: Escenario; parte?: 'fondo' | 'frente'; [opcion: string]: unknown}
 		| {tipo: 'ventana'; diametro?: number; src?: string; capas?: Capa[]; borde?: 'metal' | 'ninguno' | (string & {}); grosor?: number; remaches?: number | false; zoom?: number | [number, number]; fondo?: string}
 	);

package/lib/diccionario.mjs

@@ -19,7 +19,7 @@ export const TEMAS = {
 		casa: ['house', 'home'], cuarto: ['bedroom', 'room'], cama: ['bed'], sillon: ['sofa', 'couch', 'armchair'], sofa: ['sofa', 'couch'],
 		silla: ['chair'], mesa: ['table'], escritorio: ['desk'], lampara: ['lamp'], librero: ['bookcase', 'shelf'], refrigerador: ['fridge', 'refrigerator'],
 		estufa: ['stove', 'oven'], horno: ['oven'], lavabo: ['sink', 'bathroom sink'], fregadero: ['kitchen sink', 'sink'], inodoro: ['toilet'], banera: ['bathtub'],
-		regadera: ['shower'], espejo: ['mirror'], puerta: ['door'], ventana: ['window'], televisor: ['television', 'tv'], planta: ['plant', 'potted plant'],
+		regadera: ['shower'], espejo: ['mirror'], puerta: ['door'], ventana: ['window'], televisor: ['television', 'tv', 'monitor'], television: ['television', 'tv', 'monitor'], tele: ['television', 'tv', 'monitor'], tv: ['tv', 'television', 'monitor'], planta: ['plant', 'potted plant'],
 		alfombra: ['rug'], ropero: ['wardrobe', 'closet'], buro: ['nightstand'], cajon: ['drawer', 'cabinet'], lavadora: ['washer', 'washing machine'], microondas: ['microwave'], licuadora: ['blender'], ventilador: ['fan'], almohada: ['pillow'], cortina: ['curtain'], reloj: ['clock'], llave: ['key'], candado: ['padlock', 'lock'], cocina: ['kitchen'], bano: ['bathroom'],
 	},
 	construccion: {
@@ -69,7 +69,8 @@ export const TEMAS = {
 	tecnologia: {
 		computadora: ['computer', 'laptop'], laptop: ['laptop'], celular: ['phone', 'smartphone'], telefono: ['phone'], robot: ['robot'], chip: ['chip', 'microchip'],
 		bateria: ['battery'], enchufe: ['plug', 'socket'], foco: ['light bulb', 'bulb'], camara: ['camera'], audifonos: ['headphones'], microfono: ['microphone'],
-		control: ['gamepad', 'controller'], consola: ['console', 'game console'], antena: ['antenna'], satelite: ['satellite'], dron: ['drone'], servidor: ['server'],
+		control: ['gamepad', 'controller'], consola: ['game console', 'console', 'gamepad'], consola_portatil: ['handheld console', 'nintendo switch', 'tablet', 'gamepad'],
+		tablet: ['tablet'], monitor: ['monitor', 'screen'], pantalla: ['screen', 'monitor'], disco: ['disc', 'cd', 'compact disc'], cd: ['disc', 'cd', 'compact disc'], dvd: ['disc', 'dvd'], memoria_usb: ['usb', 'flash drive'], antena: ['antenna'], satelite: ['satellite'], dron: ['drone'], servidor: ['server'],
 		wifi: ['wifi'], nube_de_datos: ['cloud computing', 'cloud'], codigo: ['code'], teclado: ['keyboard'], raton_pc: ['computer mouse'],
 	},
 	espacio: {
@@ -97,6 +98,8 @@ export const TEMAS = {
 	juegos: {
 		videojuego: ['video game', 'gamepad'], dado: ['dice'], carta: ['playing card', 'card'], ajedrez: ['chess'], moneda_juego: ['coin'], corona: ['crown'], espada: ['sword'],
 		escudo: ['shield'], cofre_juego: ['chest'], gema: ['gem', 'crystal'], pocion: ['potion'], bandera: ['flag'], meta: ['finish line', 'flag'],
+		cartucho: ['game cartridge', 'cartridge', 'sd card', 'floppy disk'], joystick: ['joystick', 'gamepad'], arcade: ['arcade machine', 'arcade', 'gamepad'], jefe_final: ['monster', 'dragon', 'skull'],
+		vida: ['heart', 'life'], nivel: ['level', 'block', 'platform'], bloque: ['block', 'cube', 'brick'], llave_juego: ['key'], hongo: ['mushroom'], estrella_juego: ['star'],
 	},
 	fiestas: {
 		regalo: ['gift', 'present'], globo: ['balloon'], pastel_cumpleanos: ['birthday cake', 'cake'], arbol_navidad: ['christmas tree'], nieve: ['snow', 'snowman'],

package/lib/recursos.mjs

@@ -39,6 +39,8 @@ export const VARIANTES_2D = {
 	brutal: ['withicons-brutal'],
 	gothic: ['withicons-gothic'],
 	linea: ['ph', 'mdi', 'iconoir', 'tabler', 'lucide'],
+	// ilustración plana con muchísimos animales y objetos: último respaldo 2D antes de pasar a 3D
+	plano: ['fluent-emoji-flat', 'noto'],
 };
 
 async function pedirJSON(url, opciones = {}) {
@@ -252,19 +254,26 @@ export async function resolverRecursos(video, assetsPublico, log = console.log)
 		const {tipo, buscar, estilo = '3d', variante, fuente, indice: n = 0, color, ...resto} = c;
 		if (!buscar) throw new ErrorMorfeo('Una capa {tipo: "recurso"} necesita `buscar` (por ejemplo, buscar: "tubería")');
 		let res = await buscarRecursos(buscar, {estilo, variante, fuente});
-		// sin resultados en ese estilo: se intenta en los otros antes de fallar (3d → realista → 2d)
-		if (!res.length && !fuente)
-			for (const otro of ['3d', 'realista', '2d'].filter((e) => e !== estilo)) {
-				res = await buscarRecursos(buscar, {estilo: otro, variante});
+		// sin resultados: primero se prueba el mismo estilo con otra línea gráfica (2d glass → 2d color → otras
+		// variantes), y luego los otros estilos. Así un 2D no termina siendo un modelo realista si hay otro 2D.
+		if (!res.length && !fuente) {
+			const intentos =
+				estilo === '2d'
+					? [...Object.keys(VARIANTES_2D).filter((v) => v !== (variante ?? 'color') && v !== 'linea').map((v) => ['2d', v]), ['3d'], ['realista']]
+					: [...['3d', 'realista'].filter((e) => e !== estilo).map((e) => [e]), ['2d', variante]];
+			for (const [otro, otraVariante] of intentos) {
+				res = await buscarRecursos(buscar, {estilo: otro, variante: otraVariante});
 				if (res.length) {
-					log(`    "${buscar}" no está en ${estilo}; uso ${otro}`);
+					log(`    "${buscar}" no está en ${estilo}${variante ? ' ' + variante : ''}; uso ${otro}${otraVariante && otro === '2d' ? ' ' + otraVariante : ''}`);
 					break;
 				}
 			}
-		if (!res.length)
-			throw new ErrorMorfeo(
-				`No encontré "${buscar}" (${estilo}${variante ? ' ' + variante : ''}). Prueba un sinónimo, escríbelo en inglés (buscar: 'barrel'), otro estilo ('2d', '3d', 'realista'), o mira  npx morfeo recursos buscar "${buscar}"`,
-			);
+		}
+		// nada en ninguna biblioteca: se avisa y la capa se omite (el video se hace igual)
+		if (!res.length) {
+			log(`    ⚠ No encontré "${buscar}" en ninguna biblioteca; omito esa capa. Prueba un sinónimo o escríbelo en inglés:  npx morfeo recursos buscar "${buscar}"`);
+			return null;
+		}
 		const r = res[Math.min(n, res.length - 1)];
 		const d = await bajarRecurso(r, {color});
 		creditos.add(d.credito);
@@ -281,16 +290,18 @@ export async function resolverRecursos(video, assetsPublico, log = console.log)
 		log(`    recurso "${buscar}" → ${r.nombre} (${r.fuente})`);
 		return r.tipo === 'modelo'
 			? // modelos externos: cámara más cerca y menos luz ambiente para que no se vean chicos ni deslavados
-			  {tipo: 'modelo', src, ancho: 620, alto: 620, girar3d: [0, 30, 0], distancia: 4.3, camaraY: 0.9, luzAmbiente: 0.25, reflejos: 0.45, luz: 1.6, ...resto}
+			  {tipo: 'modelo', src, ancho: 620, alto: 620, girar3d: [0, 30, 0], levantar: true, distancia: 4.3, camaraY: 0.9, luzAmbiente: 0.25, reflejos: 0.45, luz: 1.6, ...resto}
 			: {tipo: 'imagen', src, ancho: 460, sombra: true, ...resto};
 		void base;
 	};
 	const recorrer = async (x) => {
-		if (Array.isArray(x)) return Promise.all(x.map(recorrer));
+		if (Array.isArray(x)) return (await Promise.all(x.map(recorrer))).filter((v) => v !== null);
 		if (!x || typeof x !== 'object') return x;
 		if (x.tipo === 'recurso') return resolver(x);
 		const out = {};
 		for (const [k, v] of Object.entries(x)) out[k] = await recorrer(v);
+		// un grupo cuya capa repetida no se encontró tampoco se dibuja
+		if (x.tipo === 'grupo' && x.capa && out.capa === null) return null;
 		return out;
 	};
 	const scenes = await recorrer(video.scenes);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "morfeo",
-	"version": "0.1.2",
+	"version": "0.1.3",
 	"description": "Genera videos verticales animados (Remotion + Three.js) con voz, música y subtítulos, desde un guion en código o escrito por IA.",
 	"type": "module",
 	"license": "SEE LICENSE IN LICENSE",

package/remotion/motor/modelo3d.tsx

@@ -25,7 +25,41 @@ const cargarGltf = (url: string) => {
 };
 const cargar = (url: string) => cargarGltf(url).then((g) => g.scene);
 
-const Glb: React.FC<{src: string}> = ({src}) => {
+/**
+ * Caja del "cuerpo" del modelo: si casi todos los vértices se juntan en una zona pequeña y el resto son
+ * hilos sueltos (el cable de un control, la cuerda de un globo), encuadra esa zona y no la caja completa.
+ */
+function cajaPrincipal(obj: THREE.Object3D): THREE.Box3 {
+	const completa = new THREE.Box3().setFromObject(obj);
+	const pts: number[] = [];
+	const v = new THREE.Vector3();
+	obj.updateMatrixWorld(true);
+	obj.traverse((o) => {
+		const m = o as THREE.Mesh;
+		const pos = m.isMesh ? (m.geometry?.attributes?.position as THREE.BufferAttribute | undefined) : undefined;
+		if (!pos) return;
+		const paso = Math.max(1, Math.floor(pos.count / 20000));
+		for (let i = 0; i < pos.count; i += paso) {
+			v.fromBufferAttribute(pos, i).applyMatrix4(m.matrixWorld);
+			pts.push(v.x, v.y, v.z);
+		}
+	});
+	if (pts.length < 300) return completa;
+	const N = 10;
+	const mn = completa.min.toArray();
+	const tam = completa.getSize(new THREE.Vector3()).toArray();
+	const celda = (i: number) => [0, 1, 2].map((k) => Math.min(N - 1, Math.floor(((pts[i + k] - mn[k]) / (tam[k] || 1)) * N))).join();
+	const cuenta = new Map<string, number>();
+	for (let i = 0; i < pts.length; i += 3) cuenta.set(celda(i), (cuenta.get(celda(i)) ?? 0) + 1);
+	const max = Math.max(...cuenta.values());
+	const caja = new THREE.Box3();
+	for (let i = 0; i < pts.length; i += 3) if ((cuenta.get(celda(i)) ?? 0) >= max * 0.2) caja.expandByPoint(v.set(pts[i], pts[i + 1], pts[i + 2]));
+	const lado = (b: THREE.Box3) => Math.max(...b.getSize(new THREE.Vector3()).toArray());
+	// solo si el cuerpo es mucho más chico que todo: en modelos normales la caja densa es casi la completa
+	return lado(caja) < 0.5 * lado(completa) ? caja.expandByScalar(lado(caja) * 0.08) : completa;
+}
+
+const Glb: React.FC<{src: string; levantar?: boolean}> = ({src, levantar}) => {
 	const url = recurso(src);
 	const [escena, setEscena] = useState<THREE.Group | null>(null);
 	const [handle] = useState(() => delayRender(`Cargando modelo ${src}`));
@@ -34,20 +68,28 @@ const Glb: React.FC<{src: string}> = ({src}) => {
 			.then((s) => {
 				// centrado y escalado a ~2 unidades para que cualquier modelo quepa en el lienzo
 				const copia = s.clone(true);
-				const caja = new THREE.Box3().setFromObject(copia);
+				const caja = levantar ? cajaPrincipal(copia) : new THREE.Box3().setFromObject(copia);
 				const tam = caja.getSize(new THREE.Vector3());
 				const centro = caja.getCenter(new THREE.Vector3());
 				const k = 2 / Math.max(tam.x, tam.y, tam.z, 0.0001);
 				copia.position.sub(centro.multiplyScalar(k));
 				copia.scale.setScalar(k);
-				setEscena(copia);
+				// objetos planos acostados (un control, un libro, un plato): de frente se ven como una raya,
+				// así que se levantan hacia la cámara
+				const plano = levantar && tam.y < 0.3 * Math.max(tam.x, tam.z);
+				if (plano) {
+					const g = new THREE.Group();
+					g.add(copia);
+					g.rotation.x = 65 * RAD;
+					setEscena(g);
+				} else setEscena(copia);
 				continueRender(handle);
 			})
 			.catch((e) => {
 				continueRender(handle);
 				throw new Error(`No pude cargar el modelo 3D ${src}: ${e.message}`);
 			});
-	}, [url, handle, src]);
+	}, [url, handle, src, levantar]);
 	return escena ? <primitive object={escena} /> : null;
 };
 
@@ -137,7 +179,7 @@ export const Modelo3D: React.FC<{c: Record<string, any>; ctx: CtxEscena}> = ({c,
 				<directionalLight position={[-4, 2, -3]} intensity={0.4} color="#9fc4ff" />
 				<group scale={c.tamano ?? 1} rotation={[rx + gx * t, ry + gy * t, rz + gz * t]} position={[0, n > 1 ? -altoPila / 2 : 0, 0]}>
 					{c.src ? (
-						<Glb src={c.src} />
+						<Glb src={c.src} levantar={c.levantar} />
 					) : (OBJETOS_3D as readonly string[]).includes(c.forma) ? (
 						<Objeto3D forma={c.forma} t={t} opciones={c} color={c.color} metal={c.metal} rugosidad={c.rugosidad} />
 					) : (

package/remotion/motor/subtitulos.tsx

@@ -80,11 +80,11 @@ export const Subtitulos: React.FC<{tema: Tema; palabras: Palabra[]; t: number; d
 
 	if (S.tipo === 'pop') {
 		return (
-			<div style={{position: 'absolute', left: 60, width: W - 120, top: S.y, transform: `translateY(-50%) scale(${backOut(entrada)})`, display: 'flex', justifyContent: 'center', flexWrap: 'wrap', gap: '0 22px'}}>
+			<div style={{position: 'absolute', left: 60, width: W - 120, top: S.y, transform: `translateY(-50%) scale(${backOut(entrada)})`, display: 'flex', justifyContent: 'center', flexWrap: 'wrap', gap: `0 ${Math.round(S.tam * 1.5 * 0.4 + 20)}px`}}>
 				{g.map(([w, a, b], i) => {
 					const activa = t >= a && t < b + 0.05;
 					return (
-						<span key={i} style={{fontFamily: tema.fuentes.titulo, fontWeight: 900, fontSize: S.tam * 1.5, color: activa ? tema.colores.acento : S.color, WebkitTextStroke: '10px #000', paintOrder: 'stroke fill', textTransform: 'uppercase', transform: `scale(${activa ? 1.1 : 1})`}}>
+						<span key={i} style={{fontFamily: tema.fuentes.titulo, fontWeight: 900, fontSize: S.tam * 1.5, color: activa ? tema.colores.acento : S.color, WebkitTextStroke: '10px #000', paintOrder: 'stroke fill', textTransform: 'uppercase', display: 'inline-block', transformOrigin: 'center bottom', transform: `scale(${activa ? 1.1 : 1})`}}>
 							{w}
 						</span>
 					);