Donnez vie à votre vie de manière procédurale avec les scripts Blender

Le script de Blender créera quelque chose ** comme celui dont on a parlé à l'Expo. Puisqu'il est généré de manière procédurale sur la base de nombres aléatoires, il est possible de générer d'innombrables modèles. La version de Blender est la 2.8.

Génération de sphères de première étape

import bpy
import numpy as np

#Placez le matériau rouge ici
bpy.data.materials.new(name = 'red')
mat_red = bpy.data.materials['red']
mat_red.use_nodes = False
mat_red.diffuse_color = (1,0,0,1)

#Génération de sphère
bpy.ops.mesh.primitive_uv_sphere_add(radius=1,location=(0,0,0))
bpy.ops.object.material_slot_add()
bpy.context.object.active_material=mat_red

Nous allons créer une sphère rouge en générant une primitive et en spécifiant un matériau simple. Vous pouvez créer une sphère UV avec bpy.ops.mesh.primitive_uv_sphere_add.

Deuxième étape: prolifération des sphères

J'aimerais créer d'innombrables sphères rouges, mais je sens que la vie brille s'il y a une sorte de continuité plutôt que de le faire simplement avec une instruction for, donc je vais l'implémenter en utilisant une fonction récursive ici. Je déciderai. Une fonction récursive est un programme qui se crée tout en le copiant (super approprié).

import bpy
import numpy as np

#Placez le matériau rouge ici
bpy.data.materials.new(name = 'red')
mat_red = bpy.data.materials['red']
mat_red.use_nodes = False
mat_red.diffuse_color = (1,0,0,1)

def add_sphere(r,x,y,z,count):
    if count > 20: #Boucle infinie sans ça
        return
    bpy.ops.mesh.primitive_uv_sphere_add(radius=r,location=(x,y,z))
    bpy.ops.object.material_slot_add()
    bpy.context.object.active_material=mat_red
    add_sphere(r,x+1,y,z,count+1) #Appelez une copie de vous-même
    return

add_sphere(1,0,0,0,1)

La sphère est générée par la fonction ʻadd_sphere, mais la fonction ʻadd_sphere y est également appelée. Mais ce n'est pas exactement la même chose, il produit une copie qui est x par 1 sur lui-même. Une boucle infinie se produit dans laquelle la copie est encore décalée de un, et un processus continu peut être décrit simplement. C'est juste un mouvement horizontal, mais avec une commande comme ʻadd_sphere (1.1 * r, y, x + 1, z, count + 1) `, cela ressemble à ceci:

Vous pouvez ressentir le mystère de la vie.

Étape 3 Ajouter le caractère aléatoire

Cependant, c'est trop régulier et je ne ressens pas la brillance. En regardant le matériau d'origine, il semble qu'un certain nombre de boules rouges de différentes tailles soient reliées pour former un anneau. Après tout, il semble qu'un sentiment de vie ressorte s'il y a une variation de taille. Les positions d'occurrence les unes des autres doivent également être façonnées de manière à passer du parent à l'enfant.

import bpy
import numpy as np #Ajouter une importation numpy

#Placez le matériau rouge ici
bpy.data.materials.new(name = 'red')
mat_red = bpy.data.materials['red']
mat_red.use_nodes = False
mat_red.diffuse_color = (1,0,0,1)

def add_sphere(r,x,y,z,count):
    if count > 20: #Boucle infinie sans ça
        return
    bpy.ops.mesh.primitive_uv_sphere_add(radius=r,location=(x,y,z))
    bpy.ops.object.material_slot_add()
    bpy.context.object.active_material=mat_red
    #Spécifiez aléatoirement la longitude et la latitude
    theta = np.random.rand()*np.pi*2
    phi = (np.random.rand()-0.5)*np.pi
    #Spécifiez de nouvelles coordonnées
    nr = r*(0.5 + np.random.rand())#La balle de l'enfant est le 0 du parent.5 fois à 1.5 fois
    nx = x+(r+nr)*np.cos(theta)*np.cos(phi)
    ny = y+(r+nr)*np.sin(theta)*np.cos(phi)
    nz = z+(r+nr)*np.sin(phi)
    add_sphere(nr,nx,ny,nz,count+1)#Appelez une copie de vous-même
    return

add_sphere(1,0,0,0,1)

Étape 4 Ajouter des globes oculaires

J'ajouterai un joli globe oculaire. Ce serait bien si je pouvais définir la texture, mais ici je vais dessiner avec uniquement des primitives.

Ça brille beaucoup. Après cela, si vous arrangez un peu l'ombrage et le restituer, vous pouvez générer une image brillante comme au début.

Le code comporte de nombreuses parties redondantes, j'ai donc simplifié certaines d'entre elles en tant que fonctions.

import bpy
import numpy as np #Ajouter une importation numpy

#L'écriture de trois paramètres matériels est longue, alors faites-en une
def create_material(color_name,r,g,b):
    bpy.data.materials.new(name = color_name)
    mat = bpy.data.materials[color_name]
    mat.use_nodes = False
    mat.diffuse_color = (r,g,b,1)
    return mat

mat_red = create_material('red',1,0,0)
mat_white = create_material('white',1,1,1)
mat_eye = create_material('eye',0,1.5,1)

#L'écriture de trois spécifications de coordonnées est longue, elle est donc partiellement fonctionnalisée
def next_params(x,y,z,theta,phi,dist):
    nx = x + dist*np.cos(theta)*np.cos(phi)
    ny = y + dist*np.sin(theta)*np.cos(phi)
    nz = z + dist*np.sin(phi)
    return nx,ny,nz

#L'écriture de trois générations de sphères UV prend beaucoup de temps, elle est donc partiellement fonctionnalisée.
def create_sphere(r,x,y,z,mat):
    bpy.ops.mesh.primitive_uv_sphere_add(radius=r,location=(x,y,z))
    bpy.ops.object.material_slot_add()
    bpy.context.object.active_material=mat
    return

#À propos, la génération d'angle est également fonctionnalisée
def create_angular():
    theta = np.random.rand()*np.pi*2
    phi = (np.random.rand()-0.5)*np.pi
    return theta,phi

def add_sphere(r,x,y,z,count):
    if count > 20: #Boucle infinie sans ça
        return
    create_sphere(r,x,y,z,mat_red)
    theta,phi = create_angular()
    nr = r*(0.5 + np.random.rand())
    nx,ny,nz = next_params(x,y,z,theta,phi,r+nr)
    add_sphere(nr,nx,ny,nz,count+1)#Appelez une copie de vous-même
    #Générer des yeux blancs (ce n'est qu'une fonction)
    theta,phi = create_angular()
    nx,ny,nz = next_params(x,y,z,theta,phi,r/3)
    create_sphere(0.8*r,nx,ny,nz,mat_white)
    #Générer l'élève (ce n'est qu'une fonction)
    nx,ny,nz = next_params(x,y,z,theta,phi,r/2)
    create_sphere(0.65*r,nx,ny,nz,mat_eye)
    return

add_sphere(1,0,0,0,1)

Réglage des paramètres de la 5ème étape

Vous pouvez voir une beauté différente de la vie en la divisant au milieu ou en réduisant la taille de la balle de l'enfant.

Si vous êtes intéressé, il peut être judicieux de jouer avec différents paramètres. Cependant, veuillez noter que si vous changez autour de count> 20, la quantité d'objets peut augmenter de façon exponentielle et Blender peut se figer selon la façon dont le programme est construit.