Michel Anders - Написание скриптов для Blender 2.49
def __call__(self):
twopi = 2*pi
col = [0,0,0,1]
nor = [0,0,1]
tex_coord = self.input.Coords
x = tex_coord[0]
y = tex_coord[1]
a = self.input.a
c = self.input.c
Noise.setRandomSeed(42)
scn = Scene.GetCurrent()
context = scn.getRenderingContext()
current_frame = context.currentFrame()
start_frame = context.startFrame()
end_frame = context.endFrame()
frames_per_second = context.fps
time = current_frame/float(frames_per_second)
Следующим шагом нужно определить, должны ли мы вычислять позиции точек удара капель заново. Это необходимо, только если величина входного сокета drops_per_second была изменена пользователем (Вы могли бы соединить этот вход с некоторым другим нодом, который будет изменять эту величину на каждом пикселе, но это плохая идея), или когда стартовый или конечный кадр анимации изменились, как эти влияния количества капель мы должны вычислять. Этот тест выполняется на выделенной строке следующего кода сравнением вновь полученных величин с сохранёнными в переменных экземпляра:
drops_per_second = self.input.Drops_per_second
# вычисление числа капель для генерации
# в период анимации
ndrops = 1 + int(drops_per_second *
(float(end_frame) – start_frame+ 1)/
frames_per_second )
if self.drops_per_second != drops_per_second
or self.ndrops != ndrops:
self.drop = [ (Noise.random(), Noise.random(),
Noise.random() + 0.5) for i in range(ndrops)]
self.drops_per_second = drops_per_second
self.ndrops = ndrops
Если мы должны вычислить позиции капель заново, мы назначаем список кортежей в переменную экземпляра self.drop, каждый из которых состоит из координат x и y позиции капли и случайного размера капли, от которой будет зависеть высота волн.
Строк оставшейся части полностью выполняются всякий раз при вызове __call__(), но выделенная строка показывает значимую оптимизацию. Поскольку капли, которые еще не упали в текущем кадре, не привносят изменений высоты, мы исключаем их из вычисления:
speed=self.input.speed
freq=self.input.freq
dampf=self.input.dampf
height = 0.0
height_dx = 0.0
height_dy = 0.0
nabla = 0.01
for i in range(1+int(drops_per_second*time)):
dropx,dropy,dropsize = self.drop[i]
position_of_maximum=speed*time-
i/float(drops_per_second)
damping = 1.0/(1.0+dampf*position_of_maximum)
distance = sqrt((x-dropx)**2+(y-dropy)**2)
height += damping*a*dropsize*
exp(-(distance-position_of_maximum)**2/c)*
cos(freq*(distance-position_of_maximum))
distance_dx = sqrt((x+nabla-dropx)**2+
(y-dropy)**2)
height_dx += damping*a*dropsize*
exp(-(distance_dx-position_of_maximum)**2/c)
* cos(freq*(distance_dx-position_of_maximum))
distance_dy = sqrt((x-dropx)**2+
(y+nabla-dropy)**2)
height_dy += damping*a*dropsize*
exp(-(distance_dy-position_of_maximum)**2/c)
*cos(freq*(distance_dy-position_of_maximum))
В предыдущем коде мы действительно вычисляем высоту в трех различных позициях, чтобы получить возможность аппроксимировать нормаль (как объяснено раньше). Эти величины используются в следующих строках, чтобы определить x и y компоненты нормали (z компонента установлена в единицу). Сама рассчитанная высота делится на количество капель (таким образом, средняя высота не изменится при изменении количества капель) и на общий коэффициент масштабирования a, который может быть задан пользователем прежде, чем будет подсоединён выходной сокет (выделено):
nor[0]=height-height_dx
nor[1]=height-height_dy
height /= ndrops * a
self.output.Height = height
N = (vec(self.shi.surfaceNormal)+0.2 *
vec(nor)).normalize()
self.output.Normal= N
__node__ = Raindrops
Рассчитанная нормаль затем добавляется к поверхностной нормали того пикселя, который мы вычисляем, таким образом, волны будут все еще хорошо выглядеть на искривленной поверхности, и нормируется перед назначением её в выходной сокет. Последняя строка как обычно определяет значимое имя для этого Pynode. Полный код и пример настройки нодов доступны как raindrops.py в файле raindrops.blend. Пример кадра из анимации показан на следующем скриншоте:
Пример нодовой сети показан на следующем скриншоте:
Грозовой перевал — материал, зависимый от наклона
В Блендере очень просто генерировать фрактальную местность (просто добавьте плоскость, перейдите в режим редактирования, выберите всё, затем несколько раз подразделите фрактально W > 3). Если Вы хотите чего-то большего, Вам в помощь существует несколько отлично разработанных скриптов (посмотрите, например, http://sites.google.com/site/androcto/Home/python-scripts/ANTLandscape_104b_249.py). Но как Вы наложите текстуры на такую местность? В этом примере мы изучим метод, выбирающий между различными входами материала, основываясь на величине угла наклона поверхности, которую мы затеняем. Это позволит нам создать эффект, при котором очень крутые откосы обычно лишены зелени, даже если они оказались ниже линии деревьев. В комбинации с высото-зависимым материалом мы сможем затенить гористую местность достаточно убедительно.
Уменьшение времени вычислений:
Pynodes в вычислительном отношении затратны, так как они вызываются для каждого видимого пикселя. Умное программирование может иногда уменьшить количество необходимых вычислений, но если требуется дальнейшее ускорение, может помочь компилятор-на-лету (just-in-time compiler). psyco является таким компилятором и, мы столкнемся с ним в последней главе, где мы будем применять его на Pynodes и посмотрим, имеет ли он какой-либо заметный эффект.
Определение уклона
Уклон может быть определен как угол между плоскостью пола и касательной к поверхности в интересующей нас точке.
Поскольку мы принимаем нашу (воображаемую) плоскость пола вытянутой горизонтально вдоль осей x и y, этот угол полностью определяется z-компонентой нормали к поверхности в этой же точке. Теперь мы можем вычислить этот угол точно (это arcsin(z/√x2+y2) ), но, как художникам, нам, возможно, в любом случае захочется иметь некоторое дополнительное управление, таким образом мы просто берем нормализованную z-компоненту нормали к поверхности и изменяем эту выходную интенсивность с помощью любого нода color ramp, который нам нравится. В пределах Pynode, нормаль поверхности является легко доступным вектором: self.input.shi.surfaceNormal. Однако есть препятствие...
Мировое пространство против пространства камеры
Нормаль поверхности, которую мы имеем в распоряжении, определена в пространстве камеры. Это означает, что, например, когда нормаль поверхности указывает прямо в камеру, она определена как (0, 0,-1). В данный момент мы хотим определить нашу нормаль поверхности в мировом пространстве. Нормаль, которая указывает прямо вверх, например, должна иметь величину (0,0,1) независимо от позиции или наклона камеры (в конце концов, растительность на горном склоне обычно не изменяется с изменением угла камеры). К счастью, мы можем провести преобразование из пространства камеры в мировое пространство, взяв матрицу камеры мирового пространства и умножив нормаль поверхности на вращающую часть этой матрицы. Результирующий код выглядит похожим на это:
class Slope(Node.Scripted):
def __init__(self, sockets):
sockets.output = [Node.Socket('SlopeX', val = 1.0),
Node.Socket('SlopeY', val = 1.0),
Node.Socket('SlopeZ', val = 1.0),]
self.offset = vec([1,1,1])
self.scale = 0.5
Заметьте, что код инициализации не определяет входных сокетов. Мы получим нормаль поверхности в позиции пикселя, который мы затеняем, из входа shader (выделено в следующей части кода). Мы определяем три отдельных выходных сокета для x, y, и z компонент наклона для удобства использования в нодовой сети. Так как мы, по большей части, используем именно z-компоненту наклона, то если мы будем иметь её доступной в отдельном сокете, нам не придётся использовать для её извлечения из вектора дополнительный нод обработки вектора.
