Thomas Larsson - Введение в написание скриптов на Питоне для Блендера 2.5x. Примеры кода Страница 9

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)))

Мир, вид и рендер

Эта программа модифицирует настройки Мира. Изображение является рендером куба по-умолчанию со встроенной камерой и освещением.

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

# File world.py

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

import bpy 

def run():

    world = bpy.context.scene.world

    # Настройки Мира

    world.use_sky_blend = True

    world.ambient_color = (0.05, 0, 0)

    world.horizon_color = (0, 0, 0.2)

    world.zenith_color = (0.04, 0, 0.04)

    # Звёзды

    sset = world.star_settings

    sset.use_stars = True

    sset.average_separation = 17.8

    sset.color_random = 1.0

    sset.distance_min = 0.7

    sset.size = 10

    # Окружающее освещение

    wset = world.light_settings

    wset.use_environment_light = True

    wset.use_ambient_occlusion = True

    wset.ao_blend_type = 'MULTIPLY'

    wset.ao_factor = 0.8

    wset.gather_method = 'APPROXIMATE'

    # Текстура "Облака" (Clouds)

    tex = bpy.data.textures.new('Clouds', type = 'CLOUDS')

    tex.cloud_type = 'GREYSCALE'

    tex.noise_type = 'SOFT_NOISE'

    tex.noise_basis = 'ORIGINAL_PERLIN'

    tex.noise_scale = 0.06

    tex.noise_depth = 1

    # Установка текстуры как активной текстуры Мира

    world.active_texture = tex

    # Retrieve texture slot

    wtex = world.texture_slots[world.active_texture_index]

    print(wtex, world.active_texture_index)

    # Настройки текстурного слота

    wtex.use_map_blend = False

    wtex.use_map_horizon = False

    wtex.use_map_zenith_down = False

    wtex.use_map_zenith_up = True

    wtex.color = (1,1,1)

    wtex.texture_coords = 'VIEW'

    wtex.zenith_up_factor = 1.0 return

if __name__ == "__main__":

    run()

Эта программа модифицирует настройки рендера, переключается на экран по-умолчанию, и изменяет камеру в 3D-виде. В конце стартует анимация, к несчастью, в старом виде.

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

# File view.py

# Изменяет вид и настройки рендера

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

import bpy 

def setRenderSettings():

    render = bpy.context.scene.render

    render.resolution_x = 720

    render.resolution_y = 576

    render.resolution_percentage = 100

    render.fps = 24

    render.use_raytrace = False

    render.use_color_management = True

    render.use_sss = False

    return 

def setDefaultCameraView():

    for scrn in bpy.data.screens:

        if scrn.name == 'Default':

            bpy.context.window.screen = scrn

            for area in scrn.areas:

                if area.type == 'VIEW_3D':

                    for space in area.spaces:

                        if space.type == 'VIEW_3D':