Введение в написание скриптов на Питоне для Блендера 2.5x. Примеры кода

Другие типы данных

Эта программа добавляет текстовый объект в 3D-пространство и устанавливает некоторые атрибуты. Заметьте, что тип данных здесь используется TextCurve; тип Text применяется для текста в текстовом редакторе.

#---------------------------------------------------------- 

# File text.py 

#---------------------------------------------------------- 

import bpy 

import math from math 

import pi  

def run(origin):

   # Создание и именование объекта TextCurve

   bpy.ops.object.text_add(

     location=origin,

     rotation=(pi/2,0,pi))

   ob = bpy.context.object

   ob.name = 'HelloWorldText'

   tcu = ob.data

   tcu.name = 'HelloWorldData'

   # Атрибуты TextCurve

   tcu.body = "Hello, world"

   tcu.font = bpy.data.fonts[0]

   tcu.offset_x = -9

   tcu.offset_y = -0.25

   tcu.shear = 0.5

   tcu.size = 3

   tcu.space_character = 2

   tcu.space_word = 4

   # Унаследованные атрибуты Curve (Кривая)

   tcu.extrude = 0.2

   tcu.use_fill_back = True

   tcu.use_fill_deform = True

   tcu.use_fill_front = True 

if __name__ == "__main__":

   run((0,0,0))

Эта программа иллюстрирует три метода установки объекта на новом слое:

1. Создать его на правильном слое.

2. Создать его в слое 1, и изменить Object.layer.

3. Создать его в слое 1, и использовать оператор для его перемещения.

Также показано, как изменять видимость слоёв.

#---------------------------------------------------------- 

# File layers.py 

#---------------------------------------------------------- 

import bpy  

def createOnLayer(mat):

   for n in range(3, 8):

   # Создание n-угольника в слое n+11

     layers = 20*[False]

     layers[n+11] = True

     bpy.ops.mesh.primitive_circle_add(

       vertices=n,

       radius=0.5,

       fill=True,

       view_align=True,

       layers=layers,

       location=(n-3,0,0)

     )

     bpy.context.object.data.materials.append(mat)

   return  

def changeLayerData(mat):

   for n in range(3, 8):

     # Создание n-угольника в слое 1

     bpy.ops.mesh.primitive_circle_add(

       vertices=n,

       radius=0.5,

       fill=True,

       view_align=True,

      location=(n-3,1,0)

     )

     bpy.context.object.data.materials.append(mat)

      # Затем перемещение его на новый слой

     ob = bpy.context.object

     ob.layers[n+11] = True

     # Удаление его из других слоев.

     layers = 20*[False]

     layers[n+11] = True

     for m in range(20):

       ob.layers[m] = layers[m]

    return  

def moveLayerOperator(mat):

   for n in range(3, 8):

     # Создание n-угольника в слое 1

     bpy.ops.mesh.primitive_circle_add(

       vertices=n,

       radius=0.5,

        fill=True,

       view_align=True,

        location=(n-3,2,0)

     )

     bpy.context.object.data.materials.append(mat)

     # Затем перемещение его на новый слой

     layers = 20*[False]

     layers[n+11] = True

     bpy.ops.object.move_to_layer(layers=layers)

   return  

def run():

   # Создание нескольких материалов

   red = bpy.data.materials.new('Red')

   red.diffuse_color = (1,0,0)

   green = bpy.data.materials.new('Green')

   green.diffuse_color = (0,1,0)

   blue = bpy.data.materials.new('Blue')

   blue.diffuse_color = (0,0,1)

   # Три метода перемещения объектов в новый слой

   createOnLayer(red)

   changeLayerData(green)

   moveLayerOperator(blue)

   # Выбор слоёв 14 - 20

   scn = bpy.context.scene

   bpy.ops.object.select_all(action='SELECT')

   for n in range(13,19):

     scn.layers[n] = True

   # Отмена выбора слоёв 1 - 13, но только впоследствии.

   # Похоже, по крайней мере один слой должен быть выбран всегда.

   for n in range(0,13):

     scn.layers[n] = False

    # Отмена выбора слоя 16

   scn.layers[15] = False

   return

if __name__ == "__main__":

   run()

Эта программа показывает, как создавать группы, добавлять объекты в группы, и пустышки, которые дублируют группы. Мы добавляем четыре группы, четыре меш-объекта назначаются каждый в две группы, и четыре текстовых объекта назначаются каждый в единственную группу. Затем мы добавляем четыре пустышки, которые будут дубликатами (dupli-group) четырёх групп. Наконец пустышки перемещаются, так что каждая колонка содержит элементы в этой группе.

#---------------------------------------------------------- 

# File groups.py

# Create groups 

#---------------------------------------------------------- 

import bpyimport mathutils 

from mathutils 

import Vector

# Слои

Display = 5 

Build = 6  

def setObject(name, mat):

   ob = bpy.context.object

   ob.name = name

   ob.data.materials.append(mat)

   return ob

# Перемещение объекта в данный слой. 

def moveToLayer(ob, layer):

   ob.layers[layer] = True

   for n in range(20):

     if n != layer:

       ob.layers[n] = False

   return

  # Добавление объекта TextCurve в слое 13 

def addText(string, loc):

   tcu = bpy.data.curves.new(string+'Data', 'FONT')

   text = bpy.data.objects.new(string+'Text', tcu)

   tcu.body = string

   tcu.align = 'RIGHT'

   text.location = loc

   bpy.context.scene.objects.link(text)

   # Нужно изменить text.layers после того, как текст будет привязан к сцене,

  # в противном случае изменение не сможет сработать. moveToLayer(text, Build)

   return text  

def run():

   # Создание двух материалов

   red = bpy.data.materials.new('RedMat')

   red.diffuse_color = (1,0,0)

   green = bpy.data.materials.new('GreenMat')

   green.diffuse_color = (0,1,0)

   # Позиции

   origin = Vector((0,0,0))

   dx = Vector((2,0,0))

   dy = Vector((0,2,0))

   dz = Vector((0,0,2))

    # Размещение объектов на слой построения (Build)

   layers = 20*[False]

   layers[Build] = True

   # Создание объектов

   bpy.ops.mesh.primitive_cube_add(location=dz, layers=layers)

   redCube = setObject('RedCube', red)

   bpy.ops.mesh.primitive_cube_add(location=dx+dz, layers=layers)

   greenCube = setObject('GreenCube', green)

   bpy.ops.mesh.primitive_uv_sphere_add(location=2*dx+dz, layers=layers)

   redSphere = setObject('RedSphere', red)

   bpy.ops.mesh.primitive_uv_sphere_add(location=3*dx+dz, layers=layers)

   greenSphere = setObject('GreenSphere', green)

    # Создание текстов

   redText = addText('Red', -dx)

   greenText = addText('Green', -dx)

   cubeText = addText('Cube', -dx)

   sphereText = addText('Sphere', -dx)

   # Создание групп

   redGrp = bpy.data.groups.new('RedGroup')

   greenGrp = bpy.data.groups.new('GreenGroup')

   cubeGrp = bpy.data.groups.new('CubeGroup')

   sphereGrp = bpy.data.groups.new('SphereGroup')

  # Таблица членов групп

 members = {

 redGrp : [redCube, redSphere, redText],

 greenGrp : [greenCube, greenSphere, greenText],

 cubeGrp : [redCube, greenCube, cubeText],

 sphereGrp : [redSphere, greenSphere, sphereText] }

   # Привязка объектов к группам

   for group in members.keys():

     for ob in members[group]:

        group.objects.link(ob)

    # Список пустышек

   empties = [

     ('RedEmpty', origin, redGrp),

     ('GreenEmpty', dy, greenGrp),

     ('CubeEmpty', 2*dy, cubeGrp),

     ('SphereEmpty', 3*dy, sphereGrp) ]

   # Создание пустышек и размещение их в слое отображения (Display)

   scn = bpy.context.scene

   for (name, loc, group) in empties:

     empty = bpy.data.objects.new(name, None)

     empty.location = loc

     empty.name = name

     empty.dupli_type = 'GROUP'

     empty.dupli_group = group

     scn.objects.link(empty)

     moveToLayer(empty, Display)

   # Слой отображения назначается активным слоем

   scn.layers[Display] = True

   for n in range(20):

     if n != Display:

       scn.layers[n] = False

   return

if __name__ == "__main__":

   run()

Эта программа добавляет ico-сферу, деформированную решёткой. Модификатор решётки действует только на группу вершин в верхней половине сферы.

#---------------------------------------------------------- 

# File lattice.py 

#---------------------------------------------------------- 

import bpy  

def createIcoSphere(origin):

   # Создание ico-сферы

   bpy.ops.mesh.primitive_ico_sphere_add(location=origin)

   ob = bpy.context.object

   me = ob.data

   # Создание групп вершин

   upper = ob.vertex_groups.new('Upper')

   lower = ob.vertex_groups.new('Lower')

   for v in me.vertices:

     if v.co[2] > 0.001:

       upper.add([v.index], 1.0, 'REPLACE')

     elif v.co[2] < -0.001:

       lower.add([v.index], 1.0, 'REPLACE')

     else: upper.add([v.index], 0.5, 'REPLACE')

      lower.add([v.index], 0.5, 'REPLACE')

   return ob  

def createLattice(origin):

   # Создание решётки и объекта

   lat = bpy.data.lattices.new('MyLattice')

   ob = bpy.data.objects.new('LatticeObject', lat)

   ob.location = origin ob.show_x_ray = True

   # Привязка объекта к сцене

   scn = bpy.context.scene

   scn.objects.link(ob)

   scn.objects.active = ob

   scn.update()

    # Установка атрибутов решётки

   lat.interpolation_type_u = 'KEY_LINEAR'

   lat.interpolation_type_v = 'KEY_CARDINAL'

   lat.interpolation_type_w = 'KEY_BSPLINE'

   lat.use_outside = False

   lat.points_u = 2

   lat.points_v = 2 lat.points_w = 2

   # Расстановка точек решётки

   s = 1.0

   points = [

     (-s,-s,-s), (s,-s,-s), (-s,s,-s), (s,s,-s),

     (-s,-s,s), (s,-s,s), (-s,s,s), (s,s,s)

   ]

   for n,pt in enumerate(lat.points):

     for k in range(3):

       pt.co_deform[k] = points[n][k]

       pass

   return ob  

def run(origin):

   sphere = createIcoSphere(origin)

   lat = createLattice(origin)

   # Создание модификатора решётки

   mod = sphere.modifiers.new('Lat', 'LATTICE')

   mod.object = lat

   mod.vertex_group = 'Upper'

   # Решётка в режиме редактирования для лёгкого деформирования

   bpy.context.scene.update()

   bpy.ops.object.mode_set(mode='EDIT')

   return

if __name__ == "__main__":

   run((0,0,0))

Эта программа добавляет кривую Безье. Она также добавляет круг Nurbs, который используется как bevel-объект.

#---------------------------------------------------------- 

# File curve.py 

#---------------------------------------------------------- 

import bpy  

def createBevelObject():

   # Создание Bevel-кривой и объекта

   cu = bpy.data.curves.new('BevelCurve', 'CURVE')

   ob = bpy.data.objects.new('BevelObject', cu)

   bpy.context.scene.objects.link(ob)

    # Настройка некоторых атрибутов cu.dimensions = '2D'

   cu.resolution_u = 6

   cu.twist_mode = 'MINIMUM'

   ob.show_name = True

   # Координаты управляющих точек

   coords = [

     (0.00,0.08,0.00,1.00),

     (-0.20,0.08,0.00,0.35),

     (-0.20,0.19,0.00,1.00),

     (-0.20,0.39,0.00,0.35),

     (0.00,0.26,0.00,1.00),

     (0.20,0.39,0.00,0.35),

     (0.20,0.19,0.00,1.00),

     (0.20,0.08,0.00,0.35)

   ]

   # Создание сплайна и установка управляющих точек

   spline = cu.splines.new('NURBS')

   nPointsU = len(coords)

   spline.points.add(nPointsU)

   for n in range(nPointsU):

     spline.points[n].co = coords[n]

   # Настройка атрибутов сплайна. Точки, вероятно, должны существовать к этому моменту.

   spline.use_cyclic_u = True

   spline.resolution_u = 6

   spline.order_u = 3

   return ob  

def createCurveObject(bevob):

   # Создание кривой и объекта

   cu = bpy.data.curves.new('MyCurve', 'CURVE')

   ob = bpy.data.objects.new('MyCurveObject', cu)

   bpy.context.scene.objects.link(ob)

    # Настройка некоторых атрибутов

   cu.bevel_object = bevob

   cu.dimensions = '3D'

   cu.use_fill_back = True

   cu.use_fill_front = True

   ob.show_name = True

   # Координаты Безье

   beziers = [

     ((-1.44,0.20,0.00), (-1.86,-0.51,-0.36), (-1.10,0.75,0.28)),

     ((0.42,0.13,-0.03), (-0.21,-0.04,-0.27), (1.05,0.29,0.21)),

     ((1.20,0.75,0.78), (0.52,1.36,1.19), (2.76,-0.63,-0.14)) ]

   # Создание сплайна и установка управляющих точек Безье

   spline = cu.splines.new('BEZIER')

   nPointsU = len(beziers)

   spline.bezier_points.add(nPointsU)

   for n in range(nPointsU):

     bpt = spline.bezier_points[n]

     (bpt.co, bpt.handle_left, bpt.handle_right) = beziers[n]

   return ob  

def run(origin):

   bevob = createBevelObject()

   bevob.location = origin

    curveob = createCurveObject(bevob)

   curveob.location = origin

   bevob.select = False

   curveob.select = True

   bpy.ops.transform.translate(value=(2,0,0))

   return

if __name__ == "__main__":

   run((0,0,0))

Эта программа иллюстрирует различие между типами кривых: POLY, NURBS и BEZIER.

#---------------------------------------------------------- 

# File curve_types.py 

#---------------------------------------------------------- 

import bpy 

from math import sin, pi

# Poly (многоугольник) и nurbs 

def makePolySpline(cu):

   spline = cu.splines.new('POLY')

   cu.dimensions = '3D'

   addPoints(spline, 8)  

def makeNurbsSpline(cu):

   spline = cu.splines.new('NURBS')

   cu.dimensions = '3D'

   addPoints(spline, 4)

   spline.order_u = 3

   return spline  

def addPoints(spline, nPoints):

   spline.points.add(nPoints-1)

   delta = 1/(nPoints-1)

   for n in range(nPoints):

     spline.points[n].co = (0, n*delta, sin(n*pi*delta), 1)

 # Безье 

def makeBezierSpline(cu):

   spline = cu.splines.new('BEZIER')

   cu.dimensions = '3D'

   order = 3

   addBezierPoints(spline, order+1)

   spline.order_u = order  

def addBezierPoints(spline, nPoints):

   spline.bezier_points.add(nPoints-1)

   bzs = spline.bezier_points

   delta = 1/(nPoints-1)

   for n in range(nPoints):

     bzs[n].co = (0, n*delta, sin(n*pi*delta))

     print(bzs[n].co)

   for n in range(1, nPoints):

     bzs[n].handle_left = bzs[n-1].co

   for n in range(nPoints-1):

     bzs[n].handle_right = bzs[n+1].co

   return spline

# Создание кривой с объектом и привязка к сцене 

def makeCurve(name, origin, dx):

   cu = bpy.data.curves.new('%sCurve' % name, 'CURVE')

   ob = bpy.data.objects.new('%sObject' % name, cu)

   (x,y,z) = origin ob.location = (x+dx,y,z)

   ob.show_name = True

   bpy.context.scene.objects.link(ob)

   return cu  

def run(origin):

   polyCurve = makeCurve("Poly", origin, 0)

   makePolySpline(polyCurve)

   nurbsCurve = makeCurve("NurbsEnd", origin, 1)

   spline = makeNurbsSpline(nurbsCurve)

   spline.use_endpoint_u = True

   nurbsCurve = makeCurve("NurbsNoend", origin, 2)

   spline = makeNurbsSpline(nurbsCurve)

   spline.use_endpoint_u = False

   bezierCurve = makeCurve("Bezier", origin, 3)

   makeBezierSpline(bezierCurve)

   return

if __name__ == "__main__":

   run((0,0,0))

Эта программа добавляет путь и обезьяну с ограничением "следовать по пути" (follow path).

#---------------------------------------------------------- 

# File path.py 

#---------------------------------------------------------- 

import bpy  

def run(origin):

   # Создание данных пути и объекта

   path = bpy.data.curves.new('MyPath', 'CURVE')

   pathOb = bpy.data.objects.new('Path', path)

   pathOb.location = origin

   bpy.context.scene.objects.link(pathOb)

    # Настройка данных пути

   path.dimensions = '3D'

   path.use_path = True

   path.use_path_follow = True

   path.path_duration = 250

   # Добавление сплайна к пути

   spline = path.splines.new('POLY')

   spline.use_cyclic_u = True

   spline.use_endpoint_u = False

  # Добавление точек к сплайну

   pointTable = [(0,0,0,0), (1,0,3,0),

     (1,2,2,0), (0,4,0,0), (0,0,0,0)]

   nPoints = len(pointTable)

   spline.points.add(nPoints-1)

   for n in range(nPoints):

      spline.points[n].co = pointTable[n]

    # Добавление обезьяны

   bpy.ops.mesh.primitive_monkey_add()

   monkey = bpy.context.object

    # Добавление ограничения "следовать по пути" обезьяне

   cns = monkey.constraints.new('FOLLOW_PATH')

   cns.target = pathOb

   cns.use_curve_follow = True

   cns.use_curve_radius = True

   cns.use_fixed_location = False

   cns.forward_axis = 'FORWARD_Z'

   cns.up_axis = 'UP_Y'

   return

if __name__ == "__main__":

   run((0,0,0))

   bpy.ops.screen.animation_play(reverse=False, sync=False)

Эта программа добавляет источник света "солнце" к сцене, и прожекторы (spot) для каждого объекта рендера на сцене. Каждый прожектор имеет ограничение TrackTo, заставляющее быть направленным на свой объект, тогда как солнце отслеживает центр всех объектов, визуализируемых на сцене.

#---------------------------------------------------------- 

# File camera.py 

# Adds one camera and several lights 

#---------------------------------------------------------- 

import bpy, mathutils, math

from mathutils import Vector

from math import pi  

def findMidPoint():

   # Нахождение позиции середины всех визуализируемых объектов

   sum = Vector((0,0,0))

   n = 0

   for ob in bpy.data.objects:

     if ob.type not in ['CAMERA', 'LAMP', 'EMPTY']:

       sum += ob.location

       n += 1

   if n == 0:

     return sum

   else:

     return sum/n  

def addTrackToConstraint(ob, name, target):

   # Добавление ограничения TrackTo

   cns = ob.constraints.new('TRACK_TO')

   cns.name = name

   cns.target = target

   cns.track_axis = 'TRACK_NEGATIVE_Z'

   cns.up_axis = 'UP_Y'

   cns.owner_space = 'WORLD'

   cns.target_space = 'WORLD'

   return  

def createLamp(name, lamptype, loc):

   # Создание источника освещения

   bpy.ops.object.add(

     type='LAMP',

     location=loc)

   ob = bpy.context.object

   ob.name = name

   lamp = ob.data

   lamp.name = 'Lamp'+name

   lamp.type = lamptype

   return ob  

def createLamps(origin, target):

   deg2rad = 2*pi/360

   sun = createLamp('sun', 'SUN', origin+Vector((0,20,50)))

   lamp = sun.data

   lamp.type = 'SUN'

   addTrackToConstraint(sun, 'TrackMiddle', target)

   for ob in bpy.context.scene.objects:

     if ob.type == 'MESH':

       spot = createLamp(ob.name+'Spot', 'SPOT', ob.location+Vector((0,2,1)))

       bpy.ops.transform.resize(value=(0.5,0.5,0.5))

       lamp = spot.data

      # Лампа

        lamp.type = 'SPOT'

       lamp.color = (0.5,0.5,0)

       lamp.energy = 0.9

        lamp.falloff_type = 'INVERSE_LINEAR'

        lamp.distance = 7.5

        # Форма луча прожектора

       lamp.spot_size = 30*deg2rad

      lamp.spot_blend = 0.3

        # Тени

      lamp.shadow_method = 'BUFFER_SHADOW'

       lamp.use_shadow_layer = True

       lamp.shadow_buffer_type = 'REGULAR'

       lamp.shadow_color = (0,0,1)

       addTrackToConstraint(spot, 'Track'+ob.name, ob)

   return  

def createCamera(origin, target):

   # Создание объекта и камеры

   bpy.ops.object.add(

     type='CAMERA',

     location=origin,

     rotation=(pi/2,0,pi))

   ob = bpy.context.object

   ob.name = 'MyCamOb'

   cam = ob.data

   cam.name = 'MyCam'

   addTrackToConstraint(ob, 'TrackMiddle', target)

   # Объектив

   cam.type = 'PERSP'

   cam.lens = 75

   cam.lens_unit = 'MILLIMETERS'

   cam.shift_x = -0.05

   cam.shift_y = 0.1

   cam.clip_start = 10.0

   cam.clip_end = 250.0

   empty = bpy.data.objects.new('DofEmpty', None)

   empty.location = origin+Vector((0,10,0))

   cam.dof_object = empty

   # Отображение

   cam.show_title_safe = True

   cam.show_name = True

   # Делаем её текущей камерой

   scn = bpy.context.scene

   scn.camera = ob

   return ob  

def run(origin):

   # Удаление всех камер и ламп

   scn = bpy.context.scene

   for ob in scn.objects:

     if ob.type == 'CAMERA' or ob.type == 'LAMP':

        scn.objects.unlink(ob)

   # Добавление пустышки в середине всех визуализируемых объектов

   midpoint = findMidPoint()

   bpy.ops.object.add(

      type='EMPTY',

      location=midpoint),

   target = bpy.context.object

   target.name = 'Target'

   createCamera(origin+Vector((50,90,50)), target)

   createLamps(origin, target)

   return

if __name__ == "__main__":

    run(Vector((0,0,0)))