Yamyam: 1版をインポートしました

2018-06-28T20:56:24Z

1版をインポートしました

2013年6月12日 (水) 12:47にwiki>Hjaarnioによる

2013-06-12T12:47:18Z

新規ページ

{{Page/Header|2.5|Doc:2.5/Manual/Animation/FCurve Modifiers|Doc:2.5/Manual/Animation/Dope Sheet}}

{{review|copy=X|text=partially}}

= Drivers =
Drivers are used to control the animation of one property based on the value of another. This means that their animated value is not controlled by the frame number, but rather by any specified channel. Drivers can take their effects from single properties, differences in rotation, or scripted Python expressions which can be edited inside the UI controls.

For example you could use the X location of a driver to control the colors (RGB curves) of a material, use the rotation of a driver to control the scale of an object, use the scale of a driver to control the shape (through shape keys) of a mesh/curve/etc., use a python function to control a constraint’s influence, and much much more…

One key usage of drivers is in character animation: for example, you can add object drivers to the relative shape keys of a face. Then, you manipulate the expressions of your character just by moving these drivers objects (which are set unrenderable, of course!). A bit like using the NLA, but even more friendly! See [[Doc:2.5/Manual/Animation/Driven Shape Keys|Driven Shape Keys]].

Although their interface and function is similar to that of an F-curve, they sit outside Actions, alongside them in the animation system hierarchy. Drivers are evaluated after Actions, so any F-Curve animation that may be in Actions on the data block will be overridden by the effects of a Driver.

== Mapping ==
A driven curve is not controlled by time (yes, we insist, but it’s ''very'' important to understand this). It’s rather its driver’s property changes that control where along the X axis of the curve its value is to be taken (i.e. the curve now maps the driver’s property value to the curve’s property value).

By default, there is a 1 to 1 mapping between the input value, and the output value, defined by a Generator F-Curve Modifier. You can create a custom mapping by deleting this modifier and entering keyframes into the graph area by pressing {{Shortcut/Keypress|ctrl}} + {{Shortcut/Mouse|lmb}}.

= Creating Drivers =
To create a driver, find the desired attribute you want to drive, in the properties panel. This will be the attribute that will be '''driven''' by another attribute.

{{Shortcut/Mouse|rmb}} on the channel and select one of the following options:

;'''{{Literal|Add Drivers}}'''
:This will create drivers for channels related to the selected one. For example, it will add drivers to the X, Y, and Z translate.

;'''{{Literal|Add Single Driver}}'''
:This will just add a single driver to the selected channel.

= Editing Drivers =
After you have created a driver, you need to specify how that channel will be driven, and by what.

The driver editor is located in the Graph Editor. You can switch from the F-Curve Editor view to the Driver view using the menu on the header.

The Driver editor displays all driver in the current scene. They are listed in the Channel pane on the left side.

If you have multiple drivers in the scene, you can toggle their visibility in the graph area. Also, you need to select the specific channel to begin editing it.

== Driver Properties ==
The driver's properties are located in the Properties Panel on the right side. (This panel is hidden, by default - you can open it by hitting {{Shortcut|n}}.)

;'''{{Literal|Update Dependencies}}'''
:Refreshes the drivers connections.

== Driver Types ==
There are several different driver types that define how the input value of the driver is calculated:

;'''{{Literal|Maximum Value}}'''
:Takes the highest value of the user variables.
;'''{{Literal|Minimum Value}}'''
:Takes the lowest value of the user variables.
;'''{{Literal|Sum Values}}'''
:Takes the sum of user variables
;'''{{Literal|Averaged Values}}'''
:Averages the values of the user variables
;'''{{Literal|Scripted Expression}}'''
:Computes a value based on a simple python expression, which can also make use of user variables. (see below)

= Variables =
User Variables are what produce the input values for a driver. You need at least one variable, unless you are using a scripted expression. When using a single variable, all the driver types listed above, except scripted expression, will produce the same value.

== Single Property ==
Use the Single Property type to call an arbitrary unique datablock from anything within the scene. This can be anything from the intensity of a lamp, to the color of a texture

== Transform Channel ==
This type allow you to control curves through an object's transform properties – hence, one driver can control separately up to nine curves (the three components of its location, rotation and scale).

To set up an object driver:
*Select the channel you want to drive.
*In the {{Literal|OB}} field that appears, enter the name of the chosen driver object.
*Unless your driver is an armature, you have only one choice in the {{Literal|Driver type}} drop-down list, {{Literal|Object}}.
*Select in the second drop-down list the property you want to drive your curve ({{Literal|Loc X}}, {{Literal|Scale Z}}, etc.).
*Choose the space in which the driver's tranform channels are evaluated

Now, your curve is no more directly controlled by the time, but rather by the value of the property you chose. The values are in Blender Units.

=== Example ===
In this example, we are going to control the size of the well-known monkey head (<code>Suzanne</code>) with the Y-location of the <code>Empty</code> driver. So, we {{Literal|Add Driver}} to the three {{Literal|ScaleX}}, {{Literal|ScaleY}} and {{Literal|ScaleZ}} channel of the <code>Suzanne</code> object (as usual, if there is no curve yet, it is automatically created). Note that for now, '''there is no curve''', so Blender applies a one-to-one mapping, as if there was virtual unitary gradient linear curves (materialized as yellow dashed lines in the pictures below). This also illustrates that you can use the same driver property (here, the Y location) for several different drivers…

{|align=center
|+'''Object drivers.'''
|Note that the {{Literal|Curve Editor}} window is pinned to <code>Suzanne</code>’s F-Curve (which allows us to select and grab the <code>Empty</code> object while keeping under our eyes the curve it drives!).
|-
|[[File:ManAnimationEditorsIpoDriversExNoCurves01.png|thumb|600px|center|The empty driver at Y = '''1.0''' gives Suzanne a scale of '''1.0'''…]]
|-
|[[File:ManAnimationEditorsIpoDriversExNoCurves02.png|thumb|600px|center|With driver at Y = '''2.0''', driven’s scale at '''2.0'''…]]
|-
|[[File:ManAnimationEditorsIpoDriversExNoCurves03.png|thumb|600px|center|And driver at Y = '''-2.0''', driven’s scale at… Oh, I think you got it!]]
|}

Now, we can use curves on drivers to get more complex behavior than the basic one-to-one mapping. Below, we have the same scene as above, but the {{Literal|ScaleY}} channel now has a pseudo-sinusoidal curve, oscillating between '''1.0''' and '''-1.0''' values on a one-frame period, created with three control points and the {{Literal|Cyclic}} extrapolation ({{Shortcut|E}}). This means that, while the X and Z components of <code>Suzanne</code>’s scale are still directly controlled by the Y location of <code>Empty</code>, the Y scale component now cyclically varies between '''1.0''' and '''-1.0''', as the following pictures illustrate.

{|align=center
|+'''Object driver with curve.'''
|-
|[[File:ManAnimationEditorsIpoDriversExWithCurves01.png|thumb|600px|The empty driver at Y = '''1.0''' gives Suzanne a scale of ('''1.0''', '''1.0''', '''1.0''')…]]
|-
|[[File:ManAnimationEditorsIpoDriversExWithCurves02.png|thumb|600px|With driver at Y = '''1.25''', driven’s scale at ('''1.25''', '''0.0''', '''1.25''')…]]
|-
|[[File:ManAnimationEditorsIpoDriversExWithCurves03.png|thumb|600px|And driver at Y = '''-2.0''', driven’s scale at ('''-2.0''', '''1.0''', '''-2.0''')!]]
|}

== Rotational Difference ==
Rotational difference works only on bones, but are nearly the same as object ones.

You set up a bone driver by entering in the {{Literal|OB}} field an armature’s name, and then selecting the {{Literal|Pose}} option in the {{Literal|Driver type}} drop-down list. Then enter the bone’s name in the {{Literal|BO}} field that appears, and select its property to be used.

Note the following specificities:
*The transformations are evaluated in the bone’s space (i.e. parent bone’s transformations, as well as whole object’s ones, have no effects).
*When using the rotation as driver property, you’ll find a limitation: the evaluated bone’s rotation is always mapped into a <code>[-180°, 180°[</code> range (which means that if you e.g. rotate your bone over the '''180°''' value, the driven object will “jump back” to its '''-180°''' X-curve-position…).
*You have an extra driver property: {{Literal|Rotation Difference}} takes the name of another bone, and uses as driver the angle’s value between the two bones.

== Distance ==
Distance mode simply takes the distance between two objects or bones

= Expression Drivers =
Python expression drivers (or “pydrivers” for short) allow you to use one-line [http://www.python.org Python] expressions as input for a channel, instead of using a property of another object, like standard drivers do. An expression in programming is any combination of symbols that can be evaluated to a definite value.

{{Warning/Important}}You do not directly control the value of the curve with these pydrivers, but rather, as with the other driver types, you control ''where along the X axis'' the curve value should be taken.

To set up an expression driver, change the driver type to Scripted Expression – it will display a standard text field where you can type your Python expression.

These drivers open up many interesting possibilities: you can use mathematical functions and more general programming to drive object animations. The only restriction is that the pydriver expression ''itself'' must return a real number when evaluated, and not e.g. a string or something else.

Examples would be using sines or cosines to make objects oscillate around a given point, or using random values at each animation frame to change some material attribute, like diffuse rgb, alpha, etc.

Note that pydriver evaluation is equivalent to what the builtin <code>eval()</code> function does, with the restriction that pydriver expressions must return real numbers (any type of number that can be automatically cast to a float).

== Valid Expressions ==
We’ve already told the basics: there is a text field where you can type an expression in Python. Here are some examples of valid expressions:

*Any real value: <source lang=python line=GESHI_NORMAL_LINE_NUMBERS>1.0</source>
*Expressions with numbers and operators: <source lang=python line=GESHI_NORMAL_LINE_NUMBERS>4.5 + 8.9 * 7.0 - (2 / 3.0)</source>
*Expressions also with variables: <source lang=python line=GESHI_NORMAL_LINE_NUMBERS>pi * 2 + 5.0</source>
*Available data: <source lang=python line=GESHI_NORMAL_LINE_NUMBERS>bpy.data.scenes['Scene'].frame_start # the start frame</source>
*A little math: <source lang=python line=GESHI_NORMAL_LINE_NUMBERS>sin(frame) # the sine of the current frame</source>
*The variables added below the expression field, via their names set in the name field

== Builtin resources and aliases ==
Pydrivers use their own global dictionary that is cached and only gets recreated when any expression fails. In this dictionary, a few modules are pre-imported, so that they can be used inside pydriver expressions.

*All from <code>builtin</code> (the default <code>builtin</code> module)
*<code>bpy</code>
*<code>bpy.mathutils.noise</code>
*<code>math</code>
*The current frame number (also for in-between frames, not only in integer numbers) as <code>frame</code>

'''Example expression:'''
<source lang=python line=GESHI_NORMAL_LINE_NUMBERS>cos(pi * frame) / noise.random())</source>

== Adding functions and variables to the namespace ==

You can create your own functions and add your own variables without the restriction of the one-line Python expression.

Acces to the namespace available to the drivers is achieved via bpy.app.driver_namespace, a read-only dictionary edited in-place. It is reset on file load and in new files, so rerunning the script that edits the namespace is necessary.

'''Example of adding custom function in a script run from the text editor or python console:'''

<source lang=python line=GESHI_NORMAL_LINE_NUMBERS> def driverFunc(val):
return val * val
bpy.app.driver_namespace['driverFunc'] = driverFunc</source>

All drivers can access this function from the expression directly.
'''Example expression:'''
<source lang=python line=GESHI_NORMAL_LINE_NUMBERS>driverFunc(frame) #the defined function with current frame as input value</source>

== Example ==
Let’s say we want to give our <code>Suzanne</code> a perfect two BU radius circle movement in the (XY) plane. This is not easy to achieve with standard curves, as you have to create perfect sinusoidal ones (for those who lost their math, a perfect circle in a Cartesian plane is obtained with <code>x = sin(t)</code> and <code>y = cos(t)</code>…). So let’s use Python drivers:

The <code>sin()</code> and <code>cos()</code> <code>math</code> functions take as input a ''radian'' value (i.e. a cycle takes <code>2π</code> frames to complete), and output a value in range <code>[-1.0, 1.0]</code>. So, to get a '''2BU''' radius circle fully walked in '''50''' frames, we have to use the following Python expression:
*For {{Literal|LocX}}: <source lang=python line=GESHI_NORMAL_LINE_NUMBERS>2.0 * sin(bpy.context.scene.frame_current*pi/25)</source>
*For {{Literal|LocY}}: <source lang=python line=GESHI_NORMAL_LINE_NUMBERS>2.0 * cos(bpy.context.scene.frame_current*pi/25)</source>

Now, <code>Suzanne</code> will go in endless circles around the world’s origin (if you want to make it turn around another point, just add an offset to the above expressions, or drive {{Literal|dLoc…}} curves…).

Note that:
*In the above example, we did not use F-curves.
*You can also get a perfect circular movement by using a [[Doc:2.4/Manual/Modeling/Curves|NURBS circle curve]] as a [[Doc:2.4/Manual/Animation/Techs/Object/Path|path]]…

== Links ==
*[http://wiki.blender.org/index.php/Doc:2.6/Manual/Extensions/Python extending Blender with python]
*[http://www.python.org Python] and its [http://www.python.org/doc documentation].
*This might be a good hunting ground for those looking for functions to try with pydrivers: http://functions.wolfram.com/ (newcomers are recommended to start with elementary ones, specially trigonometric).

{{Page/Footer|Doc:2.5/Manual/Animation/FCurve Modifiers|Doc:2.5/Manual/Animation/Dope Sheet}}

[[Category:Animation]]
[[Category:Editors]]
[[Category:FCurves]]
[[Category:Drivers]]
[[Category:Python]]

← 古い版	2018年6月28日 (木) 20:56時点における版
(相違点なし)

利用者:Hjaarnio/Manual/Animation/Editors/Graph/Drivers - 版の履歴

Yamyam: 1版 をインポートしました

2013年6月12日 (水) 12:47にwiki>Hjaarnioによる

Yamyam: 1版をインポートしました