Exemple d'analyse d'introduction à la programmation Python de Blender

Programmation Blender Python

Fonctionnalités prises en charge :

• Modifiez toutes les données (scène, maillage, particules, etc.) que l'interface utilisateur peut modifier.

• Modifiez les préférences utilisateur, les claviers et les thèmes.

• Exécutez l'outil avec vos propres paramètres.

• Créez des éléments d'interface utilisateur tels que des menus, des en-têtes et des panneaux.

• Créez de nouveaux outils.

• Créez des outils interactifs.

• Créez un nouveau moteur de rendu intégré à Blender.

• Abonnez-vous aux modifications apportées aux données et à leurs propriétés.

• Définissez de nouveaux paramètres dans les données Blender existantes.

• Utilisez Python pour dessiner des vues 3D.

Fonctionnalités (encore) manquantes :

• Créez de nouveaux types d'espace.

• Attribuez des propriétés personnalisées à chaque type.

Accès aux données

Python accède aux données de Blender de la même manière que le système d'animation et l'interface utilisateur. Cela signifie que tout paramètre pouvant être modifié via un bouton peut également être modifié depuis Python.

L'accès aux données du fichier Blender actuellement chargé peut être réalisé à l'aide du module bpy.data . Cela donne accès aux données de la bibliothèque. Par exemple : bpy.data 。这样就可以访问库数据。例如：

>>> bpy.data.objects
<bpy_collection[3], BlendDataObjects>

>>> bpy.data.scenes
<bpy_collection[1], BlendDataScenes>

>>> bpy.data.materials
<bpy_collection[1], BlendDataMaterials>

访问集合

您会注意到索引和字符串都可以用来访问集合的成员。与 Python 字典不同，这两种方法都是可用的; 但是，在运行 Blender 时，成员的索引可能会改变。

list(bpy.data.objects)
[bpy.data.objects["Cube"], bpy.data.objects["Plane"]]

>>> bpy.data.objects['Cube']
bpy.data.objects["Cube"]

>>> bpy.data.objects[0]
bpy.data.objects["Cube"]

访问属性

一旦你有了一个数据块，比如一个材料、对象、集合等，它的属性就可以被访问，就像使用图形界面更改设置一样。事实上，每个按钮的工具提示还显示了 Python 属性，它可以帮助查找在脚本中更改哪些设置。

bpy.data.objects[0].name
'Camera'

>>> bpy.data.scenes["Scene"]
bpy.data.scenes['Scene']

>>> bpy.data.materials.new("MyMaterial")
bpy.data.materials['MyMaterial']

对于测试要访问哪些数据，使用 Python Console 是很有用的，它是自己的空间类型。这支持自动完成，为您提供了一种快速探索文件中的数据的方法。

可以通过控制台快速找到的数据路径示例:

bpy.data.scenes[0].render.resolution_percentage
100
>>> bpy.data.scenes[0].objects["Torus"].data.vertices[0].co.x
1.0

数据创建/删除

当你熟悉其他 Python API 时，你可能会惊讶于 bpy API 中新的数据块不能通过调用类来创建:

bpy.types.Mesh()
Traceback (most recent call last):
  File "<blender_console>", line 1, in <module>
TypeError: bpy_struct.__new__(type): expected a single argument

用户不能在 Blender 数据库（bpy.data访问的那个）外的任何地方新建数据，因为这些数据是由 Blender 管理的(保存、加载、撤销、追加等)。

而只能使用以下方法进行数据增删：

mesh = bpy.data.meshes.new(name="MyMesh")
>>> print(mesh)
<bpy_struct, Mesh("MyMesh.001")>

bpy.data.meshes.remove(mesh)

自定义属性

Python 可以访问具有 ID 的任何数据块上的属性。当分配属性时候，如果该属性本不存在，就会新建该属性。

这些属性同样保存在 Blender 文件中，并随着对象一同继承或者复制。

bpy.context.object["MyOwnProperty"] = 42
if "SomeProp" in bpy.context.object:
    print("Property found")
# Use the get function like a Python dictionary
# which can have a fallback value.
value = bpy.data.scenes["Scene"].get("test_prop", "fallback value")
# dictionaries can be assigned as long as they only use basic types.
collection = bpy.data.collections.new("MyTestCollection")
collection["MySettings"] = {"foo": 10, "bar": "spam", "baz": {}}
del collection["MySettings"]

但是，这些自定义属性的值必须是基本的 Python 数据类型。如：

• int/float/string

• int/ float 的数组

• 字典（仅支持字符串键，值也必须是基本类型）

自定义属性在 Python 外部同样有效。它们可以通过曲线设置动画或在驱动路径中使用。

上下文 Context

能够直接通过名称或列表访问数据非常有用，但更常见的是根据用户的选择进行操作。这些上下文信息始终可从 bpy.context 中获得。

常用案例：

>>> bpy.context.object
>>> bpy.context.selected_objects
>>> bpy.context.visible_bones

请注意，上下文是只读的。这些值不能直接修改，尽管可以通过运行 API 函数或使用数据 API 进行更改。

因此这样会引发错误：bpy.context.object = obj

但是这样会正常工作：bpy.context.scene.objects.active = obj

运算符 Operators (Tools)

Operators 通常是用户从按钮、菜单项或快捷键访问的工具。从用户的角度来看，它们是一个工具，但是 Python 可以通过 bpy.ops 模块访问、设置并运行他们。

举例：

bpy.ops.mesh.flip_normals()
{'FINISHED'}
>>> bpy.ops.mesh.hide(unselected=False)
{'FINISHED'}
>>> bpy.ops.object.transform_apply()
{'FINISHED'}

Operator Cheat Sheet 给出了 Python 语法中所有操作符及其默认值的列表，以及生成的文档。这是一个了解 Blender 所有操作符的好方法。

Operator Poll()

许多的 Operators 都有自己的 Poll() 方法，该方法能检查现在的 Blender 上下文是否满足该 Operator 运行的条件。不满足时，直接调用该 Operator 将会产生错误。所以在操作一个 Operators 的时候，建议先用一下方式检查 context

if bpy.ops.view3d.render_border.poll():
    bpy.ops.view3d.render_border()

import bpy
def main(context):
    for ob in context.scene.objects:
        print(ob)
class SimpleOperator(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.simple_operator"
    bl_label = "Simple Object Operator"
    @classmethod
    def poll(cls, context):
        return context.active_object is not None
    def execute(self, context):
        main(context)
        return {'FINISHED'}
def register():
    bpy.utils.register_class(SimpleOperator)
def unregister():
    bpy.utils.unregister_class(SimpleOperator)
if __name__ == "__main__":
    register()
# test call
bpy.ops.object.simple_operator()

import bpy
class HelloWorldPanel(bpy.types.Panel):
    """Creates a Panel in the Object properties window"""
    bl_label = "Hello World Panel"
    bl_idname = "OBJECT_PT_hello"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "object"
    def draw(self, context):
        layout = self.layout
        obj = context.object
        row = layout.row()
        row.label(text="Hello world!", icon='WORLD_DATA')
        row = layout.row()
        row.label(text="Active object is: " + obj.name)
        row = layout.row()
        row.prop(obj, "name")
        row = layout.row()
        row.operator("mesh.primitive_cube_add")
def register():
    bpy.utils.register_class(HelloWorldPanel)
def unregister():
    bpy.utils.unregister_class(HelloWorldPanel)
if __name__ == "__main__":
    register()

Accès aux collections

Vous remarquerez que les index et les chaînes peuvent être utilisés pour accéder aux membres d'une collection. Contrairement aux dictionnaires Python, les deux méthodes sont disponibles cependant, l'index d'un membre peut changer lors de l'exécution de Blender ;

>>> C.object.rotation_mode = 'AXIS_ANGLE'

# setting multiple camera overlay guides
bpy.context.scene.camera.data.show_guide = {'GOLDEN', 'CENTER'}
# passing as an operator argument for report types
self.report({'WARNING', 'INFO'}, "Some message!")

>>> bpy.context.object
bpy.data.objects['Cube']

Accès aux propriétés

• Une fois que vous disposez d'un bloc de données, tel qu'un matériau, un objet, une collection, etc., ses propriétés sont accessibles tout comme la modification des paramètres à l'aide de l'interface graphique. En fait, l'info-bulle de chaque bouton affiche également les propriétés Python, ce qui peut aider à déterminer quels paramètres ont été modifiés dans le script.

  >>> C.scene.objects
  bpy.data.scenes['Scene'].objects

  bpy.context.object.matrix_world @ bpy.context.object.data.verts[0].co

  # modifies the Z axis in place.
  bpy.context.object.location.z += 2.0
  # location variable holds a reference to the object too.
  location = bpy.context.object.location
  location *= 2.0
  # Copying the value drops the reference so the value can be passed to
  # functions and modified without unwanted side effects.
  location = bpy.context.object.location.copy()

  Pour tester les données auxquelles vous souhaitez accéder, il est utile d'utiliser la console Python, qui est son propre type spatial. Cela prend en charge la saisie semi-automatique, vous permettant d'explorer rapidement les données de vos fichiers.
• Exemples de chemins de données pouvant être rapidement trouvés via la console :

  obj = bpy.context.object
  obj.location[2] = 0.0
  obj.keyframe_insert(data_path="location", frame=10.0, index=2)
  obj.location[2] = 1.0
  obj.keyframe_insert(data_path="location", frame=20.0, index=2)

  Création/suppression de données🎜🎜Lorsque vous êtes familier avec d'autres API Python, vous serez peut-être surpris que de nouveaux blocs de données dans l'API bpy ne puissent pas être créés en appelant classes :🎜

  obj = bpy.context.object
  obj.animation_data_create()
  obj.animation_data.action = bpy.data.actions.new(name="MyAction")
  fcu_z = obj.animation_data.action.fcurves.new(data_path="location", index=2)
  fcu_z.keyframe_points.add(2)
  fcu_z.keyframe_points[0].co = 10.0, 0.0
  fcu_z.keyframe_points[1].co = 20.0, 1.0

  🎜Les utilisateurs ne peuvent pas créer de nouvelles données n'importe où en dehors de la base de données Blender (celle accessible par bpy.data), car ces données sont gérées par Blender (enregistrer, charger, annuler, ajouter, etc. ). 🎜🎜Et les données ne peuvent être ajoutées et supprimées qu'en utilisant les méthodes suivantes : 🎜rrreeerrreee🎜Attributs personnalisés🎜🎜Python peut accéder aux attributs de n'importe quel bloc de données avec ID. Lors de l'attribution d'un attribut, si l'attribut n'existe pas, il sera créé. 🎜🎜Ces propriétés sont également enregistrées dans le fichier Blender et héritées ou copiées avec l'objet. 🎜rrreee🎜Cependant, les valeurs 🎜de ces propriétés personnalisées doivent 🎜 être des types de données Python de base. Tels que : 🎜🎜🎜🎜int/float/string🎜🎜🎜🎜int/ float <Array 🎜🎜🎜🎜Dictionnaire de /code> (seules les clés de chaîne sont prises en charge, les valeurs doivent également être de types primitifs) 🎜🎜🎜🎜Les attributs personnalisés sont également valides en dehors de Python. Ils peuvent être animés via des courbes ou utilisés dans des chemins de circulation. 🎜🎜Contexte Contexte🎜🎜 Pouvoir accéder aux données directement par nom ou par liste est très utile, mais le plus souvent, cela se fait en fonction de la sélection de l'utilisateur. Ces informations contextuelles sont toujours disponibles depuis <code>bpy.context. 🎜🎜Cas courants : 🎜rrreee🎜🎜Veuillez noter🎜 que le contexte est en lecture seule. Ces valeurs ne peuvent pas être modifiées directement, bien qu'elles puissent être modifiées en exécutant des fonctions API ou en utilisant l'API de données. 🎜🎜Donc, cela 🎜génèrera l'erreur🎜 : bpy.context.object = obj🎜🎜Mais cela fonctionnera bien : bpy.context.scene.objects.active = obj</code > 🎜🎜Opérateurs (outils)🎜🎜Les opérateurs sont généralement des outils auxquels les utilisateurs accèdent à partir de boutons, d'éléments de menu ou de touches de raccourci. Du point de vue de l'utilisateur, il s'agit d'un outil, mais Python peut y accéder, les configurer et les exécuter via le module <code>bpy.ops. 🎜🎜Exemple : 🎜rrreee🎜Operator Cheat Sheet donne une liste de tous les opérateurs en syntaxe Python et leurs valeurs par défaut, ainsi que la documentation générée. C'est un excellent moyen d'en apprendre davantage sur tous les opérateurs de Blender. 🎜

  Operator Poll()

  🎜De nombreux opérateurs ont leur propre méthode Poll(), qui peut vérifier si le contexte actuel de Blender remplit les conditions d'exécution de l'opérateur. En cas d'insatisfaction, l'appel direct à l'opérateur générera une erreur. Ainsi, lorsque vous utilisez un opérateur, 🎜recommande🎜 vérifiez d'abord le contexte de la manière suivante : 🎜rrreee🎜Comment intégrer Python dans Blender🎜🎜Les scripts Python peuvent être intégrés à Blender des manières suivantes : 🎜🎜 🎜 🎜En définissant le moteur de rendu. 🎜🎜🎜🎜En définissant des opérateurs. 🎜

• 通过定义菜单，标题和面板。

• 通过将新按钮插入现有菜单，标题和面板

在 Python 中，这是通过定义一个类来完成的，该类是现有类型的子类。

Blender 官方文档中提供了实例的类模板。如：

示例运算符

import bpy
def main(context):
    for ob in context.scene.objects:
        print(ob)
class SimpleOperator(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.simple_operator"
    bl_label = "Simple Object Operator"
    @classmethod
    def poll(cls, context):
        return context.active_object is not None
    def execute(self, context):
        main(context)
        return {'FINISHED'}
def register():
    bpy.utils.register_class(SimpleOperator)
def unregister():
    bpy.utils.unregister_class(SimpleOperator)
if __name__ == "__main__":
    register()
# test call
bpy.ops.object.simple_operator()

一旦这个脚本运行，SimpleOperator 在 Blender 中注册，可以从 Operator Search 中调用或添加到工具栏中。

运行脚本:

• 启动 Blender 并切换到脚本工作区。

• 单击文本编辑器中的 New 按钮以创建新的文本数据块。

• 从上面并将其粘贴到文本编辑器中。

• 单击 Run Script 按钮。

• 将光标移至 3D 视口，打开运算符搜索菜单，输入 “Simple”。

• 点击搜索中找到的 “SimpleOperator” 项目。

示例面板

面板注册为一个类，就像操作符一样。请注意用于设置它们所显示的上下文的额外 bl_ 变量。

import bpy
class HelloWorldPanel(bpy.types.Panel):
    """Creates a Panel in the Object properties window"""
    bl_label = "Hello World Panel"
    bl_idname = "OBJECT_PT_hello"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "object"
    def draw(self, context):
        layout = self.layout
        obj = context.object
        row = layout.row()
        row.label(text="Hello world!", icon='WORLD_DATA')
        row = layout.row()
        row.label(text="Active object is: " + obj.name)
        row = layout.row()
        row.prop(obj, "name")
        row = layout.row()
        row.operator("mesh.primitive_cube_add")
def register():
    bpy.utils.register_class(HelloWorldPanel)
def unregister():
    bpy.utils.unregister_class(HelloWorldPanel)
if __name__ == "__main__":
    register()

运行脚本:

• 启动 Blender 并切换到脚本工作区。

• 单击文本编辑器中的 New 按钮以创建新的文本数据块。

• 从上面并将其粘贴到文本编辑器中。

• 单击 Run Script 按钮。

要查看结果:

• 选择默认立方体。

• 点击按钮面板中的对象属性图标(最右边;出现为一个小立方体)。

• 向下滚动查看名为 “Hello World Panel” 的面板。

• 更改对象名称也会更新 Hello World Panel 的 name:字段。

请注意通过代码定义的行分布以及标签和属性。

数据类型

Blender 定义了许多 Python 类型，但也使用 Python 本机类型。

原生类型

在简单的情况下，将数字或字符串作为自定义类型会很麻烦，因此可以将它们作为普通的 Python 类型进行访问。

• Blender float / int / boolean-> float / int / boolean

• Blender 枚举器->字符串

>>> C.object.rotation_mode = 'AXIS_ANGLE'

• Blender枚举器（多个）->字符串集

# setting multiple camera overlay guides
bpy.context.scene.camera.data.show_guide = {'GOLDEN', 'CENTER'}
# passing as an operator argument for report types
self.report({'WARNING', 'INFO'}, "Some message!")

内部类型

用于 Blender 数据块和 Blender 集合： bpy.types.bpy_struct

用于包含 collections/meshes/bones/scenes 等属性的数据。

包装 Blenders 数据的主要类型有 2 种，

• 一种用于数据块（内部称为 bpy_struct）

>>> bpy.context.object
bpy.data.objects['Cube']

• 另一种用于属性。

>>> C.scene.objects
bpy.data.scenes['Scene'].objects

Mathutils 类型

用于表示向量，四元数，euler，矩阵和颜色类型等，可从 mathutils 模块访问它们。

一些属性，如 bpy.types.Object.location, bpy.types.PoseBone.rotation_euler 和 bpy.types.Scene.Cursor_location 可以作为特殊的数学类型访问，这些类型可以一起使用并以各种有用的方式进行操作。

例如，矩阵向量的乘法

bpy.context.object.matrix_world @ bpy.context.object.data.verts[0].co

注意：mathutils 类型保留对 Blender 内部数据的引用，这样更改就可以应用回来。

举个例子

# modifies the Z axis in place.
bpy.context.object.location.z += 2.0
# location variable holds a reference to the object too.
location = bpy.context.object.location
location *= 2.0
# Copying the value drops the reference so the value can be passed to
# functions and modified without unwanted side effects.
location = bpy.context.object.location.copy()

动画

有两种方法可以通过 Python 添加关键帧。

• 第一种是直接通过键属性，这类似于用户从按钮插入关键帧。

• 您也可以手动创建曲线和关键帧数据，然后将路径设置为属性。

这是这两种方法的示例。这两个示例都在活动对象的 Z 轴上插入关键帧。

简单的例子：

obj = bpy.context.object
obj.location[2] = 0.0
obj.keyframe_insert(data_path="location", frame=10.0, index=2)
obj.location[2] = 1.0
obj.keyframe_insert(data_path="location", frame=20.0, index=2)

使用低级功能：

obj = bpy.context.object
obj.animation_data_create()
obj.animation_data.action = bpy.data.actions.new(name="MyAction")
fcu_z = obj.animation_data.action.fcurves.new(data_path="location", index=2)
fcu_z.keyframe_points.add(2)
fcu_z.keyframe_points[0].co = 10.0, 0.0
fcu_z.keyframe_points[1].co = 20.0, 1.0

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!