[Blender x Python] Lass uns zufällig meistern !!

Dieses Mal werden wir einen Mechanismus zum zufälligen Anordnen einer großen Anzahl von Objekten einführen.

Inhaltsverzeichnis

0. Wie bekomme ich eine Zufallszahl?
1. Lassen Sie Würfel an zufälligen Positionen erscheinen
2. Erstellen Sie eine Funktion zum Organisieren des Prozesses
3. Beispielcode
4. Englische Wörter Referenzmaterial

0. Wie bekomme ich eine Zufallszahl?

Dieses Mal verwenden wir die Funktion rand () in einer Bibliothek (einer Sammlung nützlichen Codes) namens ** numpy **.

Die Funktion rand () gibt einen Zufallswert ** von ** 0 bis 1 zurück. Das Argument (Parameter) gibt an, wie viele Zufallszahlen zurückgegeben werden sollen. Wenn es Rand (3) ist, werden 3 Zufallszahlen zurückgegeben.

import numpy as np

#np.Sie können sich Zufall als nach rechts zeigenden Pfeil vorstellen und ihn ignorieren.
np.random.rand(3)

Point:import numpy as np Die Bibliothek mit dem Namen numpy wird im Code als np abgekürzt.

array([0.90681482, 0.04813658, 0.47969033])

↑ Es werden drei Zufallswerte im Bereich von 0 bis 1 ausgegeben.

• Array bedeutet ein Array, aber diesmal müssen Sie sich keine Sorgen machen. Es ist wie ein Container mit Zahlen in der richtigen Reihenfolge.

1. Lassen Sie Würfel an zufälligen Positionen erscheinen

1-0. Lassen wir den Würfel in zufälligen Positionen erscheinen !!

Verwenden Sie die Bibliothek numpy für die numerische Berechnung

import bpy
import numpy as np

bpy.ops.mesh.primitive_cube_add(location = np.random.rand(3))

Point:rand( ) Generieren Sie einen zufälligen Wert von 0 bis 1. Das Argument bestimmt, wie viele Werte zurückgegeben werden sollen. rand (3) gibt drei zufällige Werte zurück.

• Auf dem Foto wurden der variablen Position drei Zufallswerte → (0,0291909, 0,379929, 0,395483) zugewiesen.

1-1. Lassen Sie uns den Bereich angeben, in dem der Würfel angezeigt wird

○ Ruft eine Zufallszahl im Bereich von -10 oder mehr und weniger als 10 ab. Der Code hat die folgende Struktur.

Ordnen Sie der Variablen □ Daten (Informationen) zu und führen Sie die Verarbeitung mit diesen Daten aus. Und Sie können sich die Punkte als nach rechts zeigende Pfeile vorstellen (fast vernachlässigbar).

□ ← Zufällige numerische Daten
===>Funktion( □ )

import bpy
import numpy as np

#Variable zufällig_Erstellen Sie einen Ort und weisen Sie einen zufälligen Wert zu
random_location = (10 - (-10)) * np.random.rand(3) + (-10)
bpy.ops.mesh.primitive_cube_add(location = random_location)

Punkt: ** Numerischer Wert innerhalb eines bestimmten Bereichs ** Die Formel, um einen zufälligen Wert im Bereich von min oder mehr und weniger als max zu erhalten, lautet (max-min) * np.random.rand() + min ist.

Mit anderen Worten ** Bereich, in dem die Zahlen schwanken * Zufälliger Wert von 0 bis 1 + Beginn des Bereichs ** darüber.

In diesem Beispiel erhalten wir (Zufalls-) Zahlen im Bereich +20 von -10. Bereich → (-10, ..- 9, ..0, ..9, ..10)

2. Erstellen Sie eine Funktion zum Organisieren des Prozesses

2-0. Erstellen Sie eine Funktion, die eine Zufallszahl zurückgibt, und eine Funktion, mit der ein Würfel angezeigt wird.

import bpy
import numpy as np

#Definieren einer Funktion zum Generieren von drei Zufallswerten
def get_random_location(min,max):
    return (max - min) * np.random.rand(3) + min

#get_random_location()Definition einer Funktion, die einen Würfel mit dem von der Funktion generierten Wert erscheinen lässt
def generate_random_cube(min,max):
    random_location = get_random_location(min,max)
    bpy.ops.mesh.primitive_cube_add(location = random_location)

generate_random_cube(-10,10)

Point:Return Es wird in Form von "Rückgabeinformationen" verwendet, wenn die Funktion einige Informationen ausgibt.

2-1 Erstellen Sie eine Funktion, mit der mehrere Würfel an zufälligen Positionen angezeigt werden

import bpy
import numpy as np

#Definieren einer Funktion zum Generieren von drei Zufallswerten
def get_random_location(min,max):
    return (max - min) * np.random.rand(3) + min

#get_random_location()Definition einer Funktion, die einen Würfel mit dem von der Funktion generierten Wert erscheinen lässt
def generate_random_cube(min,max):
    random_location = get_random_location(min,max)
    bpy.ops.mesh.primitive_cube_add(location = random_location)

#Definition einer Funktion, bei der mehrere Würfel an zufälligen Positionen angezeigt werden
def generate_random_cubes(min,max,num):
    for i in range(0,num):
        generate_random_cube(min,max)

generate_random_cubes(-10,10,200)

2-2. Lassen Sie mehrere Würfel mit zufälligen Winkeln an zufälligen Positionen erscheinen

import bpy
import math
import numpy as np

#Definieren einer Funktion zum Generieren von drei Zufallswerten
def get_random_location(min,max):
    return (max - min) * np.random.rand(3) + min

#random_number()Definition einer Funktion, die sich dreht und einen Würfel mit dem von der Funktion generierten Wert erscheinen lässt
def generate_random_rotate_cube(min,max):
    random_location = get_random_location(min,max)
    bpy.ops.mesh.primitive_cube_add(location = random_location,rotation = math.pi * np.random.rand(3))

#Definition einer Funktion, die sich dreht und mehrere Würfel an zufälligen Positionen erscheinen lässt
def generate_random_rotate_cubes(min,max,num):
    for i in range(0,num):
        generate_random_rotate_cube(min,max)

generate_random_rotate_cubes(-10,10,200)

3. Beispielcode

Erstellen Sie eine Funktion, die die Farbe zufällig bestimmt

○ Platzieren Sie bunte Würfel an zufälligen Positionen und in zufälligen Winkeln.

import bpy
import math
import numpy as np

#Definition der Funktion, die das Material bestimmt
def material(name = 'material'):
    material_glass = bpy.data.materials.new(name)
    #Stellen Sie den Knoten zur Verfügung
    material_glass.use_nodes = True
    p_BSDF = material_glass.node_tree.nodes["Principled BSDF"]
    #0→BaseColor/7→roughness(=Rauheit)/15→transmission(=Vermehrung)
    #default_value = (R, G, B, A)
    p_BSDF.inputs[0].default_value = np.random.rand(4)
    p_BSDF.inputs[7].default_value = 0
    p_BSDF.inputs[15].default_value = 1
    #Fügen Sie einem Objekt Materialelemente hinzu
    bpy.context.object.data.materials.append(material_glass)

#Definieren einer Funktion zum Generieren von drei Zufallswerten
def get_random_location(min,max):
    return (max - min) * np.random.rand(3) + min

#random_number()Definition einer Funktion, die sich dreht und einen Würfel mit dem von der Funktion generierten Wert erscheinen lässt
def generate_random_rotate_cube(min,max):
    random_location = get_random_location(min,max)
    bpy.ops.mesh.primitive_cube_add(location = random_location,rotation = math.pi * np.random.rand(3))

#Definition einer Funktion, die sich dreht und mehrere Würfel an zufälligen Positionen erscheinen lässt
def generate_random_rotate_colorful_cubes(min,max,num):
    for i in range(0,num):
        generate_random_rotate_cube(min,max)
        material('Random')


generate_random_rotate_colorful_cubes(-10,10,200)

    

Erstellen Sie eine Funktion, die Würfel beim Drehen anordnet

import bpy
import math
import numpy as np

#Definition der Funktion, die das Material bestimmt
def material(name = 'material'):
    material_glass = bpy.data.materials.new(name)
    #Stellen Sie den Knoten zur Verfügung
    material_glass.use_nodes = True
    p_BSDF = material_glass.node_tree.nodes["Principled BSDF"]
    #0→BaseColor/7→roughness(=Rauheit)/15→transmission(=Vermehrung)
    #default_value = (R, G, B, A)
    p_BSDF.inputs[0].default_value = np.random.rand(4)
    p_BSDF.inputs[7].default_value = 0
    p_BSDF.inputs[15].default_value = 1
    #Fügen Sie einem Objekt Materialelemente hinzu
    bpy.context.object.data.materials.append(material_glass)

#Definition einer Funktion, die bunte Würfel beim Drehen anordnet
def spiral_colorful_cubes():
    #100 mal iterieren
    for i in range(0,100):
        bpy.ops.mesh.primitive_cube_add(
            #Bewegen Sie sich nach und nach nach oben
            location=(0, 0, i/50),
            scale=(1, 1, 0.05),
            #180 * i * 36(Jedes Mal)Verschieben Sie einen nach dem anderen
            rotation = (0, 0, math.pi*i*10/360)
            )
        #Fügen Sie einem Objekt Materialelemente hinzu
        material('Random')

#Verarbeitung durchführen
spiral_colorful_cubes()

Erstellen Sie eine Funktion, die den Torus transformiert, dreht und anordnet

import bpy
import math
import numpy as np

#Definition der Funktion, die das Material bestimmt
def material(name = 'material'):
    material_glass = bpy.data.materials.new(name)
    #Stellen Sie den Knoten zur Verfügung
    material_glass.use_nodes = True
    p_BSDF = material_glass.node_tree.nodes["Principled BSDF"]
    #0→BaseColor/7→roughness(=Rauheit)/15→transmission(=Vermehrung)
    #default_value = (R, G, B, A)
    p_BSDF.inputs[0].default_value = np.random.rand(4)
    p_BSDF.inputs[7].default_value = 0
    p_BSDF.inputs[15].default_value = 1
    #Fügen Sie einem Objekt Materialelemente hinzu
    bpy.context.object.data.materials.append(material_glass)

#Definition einer Funktion, die den Torus und die Farben jeweils transformiert und verschiebt
def colorful_torus_spiral():
    for i in range(0,36):
        bpy.ops.mesh.primitive_torus_add(
            location=(0, 0, 0),
            major_radius=1.0,
            minor_radius=0.01,
            )
        #In Richtung der Y-Achse schrumpfen
        bpy.ops.transform.resize(value=(1, 0.3, 1))
        #Um die Z-Achse drehen
        bpy.ops.transform.rotate(value=math.pi*i*10/360,orient_axis='Z')
        #Fügen Sie einem Objekt Materialelemente hinzu
        material('Random')

colorful_torus_spiral()

4. Englische Wörter

Referenzmaterial

Referenz: Mit Blender x Python automatisch eine große Menge lebenden Partikels generieren