November 22nd at 10:34am

Mikaël

Utilisation actuelle des llm avec blender :

-Scripter la modélisation en se basant sur le log du fichier blender (exemple : https://www.youtube.com/watch?v=2jOgGMxDVug)

• -Utilisation du llm pour intéragier avec la scéne 3d ( https://vis-www.cs.umass.edu/3dllm/)

Piste de travail dans l'intégration dans blender :

• Utiliser l'erreur du llm pour aider la créativité.

• Utiliser les llm pour automatiser les taches répétitives

Projet initiale :

Intégrer un llm dans blender pour faciliter des taches pouvant être automatiser comme la retopologie ou le weight painting.

(Probleme: travail trop complexe et le resultat ne seras pas meilleur que des outils déja existant)

Nouveau projet :

Etant donner que l'ia génère beaucoup d'erreur en début de production, se servir de ça pour créer des système de nodes permettant d'exploiter des failles qu'on cherche habituellement à éviter.

l'intérêt du géometrie nodes peut être d'avoir des valeurs aléatoires ou qui peuvent être modifier et d'avoir un système avec des erreurs qu'on peut varier plutôt qu'une modélisation figé avec des erreurs.

Essai de code 9 :

import bpy import random

Fonction pour créer un plan avec un scatter de cubes

import bpy

def create_geometry_nodes_scatter(surface_object_name, instance_object_name, density=10, scale=(0.2, 0.2, 0.2)): """ Crée un système de nœuds Geometry Nodes pour disperser des instances sur une surface.

Args:
    surface_object_name (str): Le nom de l'objet surface sur lequel instancier.
    instance_object_name (str): Le nom de l'objet à instancier.
    density (float, optional): Densité des instances. Par défaut : 10.
    scale (tuple, optional): Échelle des instances (X, Y, Z). Par défaut : (0.2, 0.2, 0.2).
"""

# Récupérer les objets
surface_object = bpy.data.objects.get(surface_object_name)
instance_object = bpy.data.objects.get(instance_object_name)

if not surface_object or not instance_object:
    print(f"Erreur : Objet '{surface_object_name}' ou '{instance_object_name}' introuvable.")
    return

# Créer un nouveau groupe de nœuds
node_group = bpy.data.node_groups.new(name="ScatterNodes", type='GeometryNodeTree')

# Créer les nœuds et définir leurs positions
input_node = node_group.nodes.new('NodeGroupInput')
input_node.location = (-300, 0)

output_node = node_group.nodes.new('NodeGroupOutput')
output_node.location = (300, 0)

distribute_points_node = node_group.nodes.new('GeometryNodeDistributePointsOnFaces')
distribute_points_node.location = (-150, 0)

instance_on_points_node = node_group.nodes.new('GeometryNodeInstanceOnPoints')
instance_on_points_node.location = (0, 0)

object_info_node = node_group.nodes.new('GeometryNodeObjectInfo')
object_info_node.location = (-150, 200)

# Configurer les nœuds
distribute_points_node.inputs['Density'].default_value = density
instance_on_points_node.inputs['Scale'].default_value = scale
object_info_node.inputs['Object'].default_value = instance_object

# Connecter les nœuds
links = node_group.links
links.new(input_node.outputs[0], distribute_points_node.inputs['Mesh'])
links.new(distribute_points_node.outputs['Points'], instance_on_points_node.inputs['Points'])
links.new(instance_on_points_node.outputs['Instances'], output_node.inputs[0])
links.new(object_info_node.outputs['Geometry'], instance_on_points_node.inputs['Instance'])

# Ajouter le modificateur Geometry Nodes
geo_mod = surface_object.modifiers.new(name="Scatter", type='NODES')
geo_mod.node_group = node_group

# Masquer l'objet instance (optionnel)
instance_object.hide_viewport = True
instance_object.hide_render = True

Utilisation :

create_geometry_nodes_scatter("MonPlan", "MonCube", density=20, scale=(0.3, 0.5, 0.2))