Reference:Animation Options - Revision history

Clipka: Indexentries fix

2016-12-16T14:58:02Z

Indexentries fix

Jholsenback: noting deprecation

2016-12-08T15:58:32Z

noting deprecation

Clipka: indexentry fix

2016-05-03T23:00:40Z

indexentry fix

Jholsenback: indexentry tag repair

2015-03-10T18:45:54Z

indexentry tag repair

Jholsenback: 1 revision: underscore link repair

2012-07-17T18:09:34Z

1 revision: underscore link repair

Jholsenback: testing a theroy

2012-07-11T17:22:45Z

testing a theroy

Jholsenback: broken line repair

2012-03-29T20:36:59Z

broken line repair

Jholsenback: 1 revision: Reference Migration Initial Load

2012-03-15T19:05:03Z

1 revision: Reference Migration Initial Load

Jholsenback: link repair

2012-03-14T12:49:13Z

link repair

New page

[[Category:Command-Line and INI-File Options]]
{{#indexentry:Animation, options|Options, animation}}
Internal animation loop, automatic output file name numbering and the
ability to shell out to the operating system to external utilities which can
assemble individual frames into an animation, greatly improved the animation capability.
The internal animation loop is simple yet flexible. You may still use external programs or batch files to
create animations without the internal loop.

{{#indexentry:Animation, external loop}}
{{#indexentry:+k}}
==External Animation Loop==
<table width="100%" class="option-list">
<tr>
<td width="30%"><code>Clock=</code>n.n</td>

<td width="70%">Sets <code>[[Reference:Numeric_Expressions#Built-in_Variables|:clock|clock]]</code> float identifier to n.n</td>
</tr>

<tr>
<td><code>+K</code>n.n</td>

<td>Same as <code>Clock=</code>n.n</td>
</tr>
</table>
{{#indexentry:Clock, ini-option}}
The <code>Clock=</code>n.n option or the <code>
+K</code>n.n switch may be used to pass a single float value to the
program for basic animation. The value is stored in the float identifier
<code>clock</code>. If an object had a <code>rotate <0,clock,0></code>
attached then you could rotate the object by different amounts over different
frames by setting <code> +K10.0</code>,<code>+K20.0</code>... etc. on
successive renderings. It is up to the user to repeatedly invoke POV-Ray with
a different <code> Clock</code> value and a different <code>
Output_File_Name</code> for each frame.

{{#indexentry:Animation, internal loop}}
==Internal Animation Loop==
<table width="100%" class="option-list">
<tr>
<td width="30%"><code>Initial_Frame=</code>n</td>{{#indexentry:Initial_Frame, ini-option}}

<td width="70%">Sets initial frame number to n</td>
</tr>

<tr>
<td><code>Final_Frame=</code>n</td>{{#indexentry:Final_Frame, ini-option}}

<td>Sets final frame number to n</td>
</tr>

<tr>
<td><code>Initial_Clock=</code>n.n</td>{{#indexentry:Initial_Clock, ini-option}}

<td>Sets initial clock value to n.n</td>
</tr>

<tr>
<td><code>Final_Clock=</code>n.n</td>{{#indexentry:Final_Clock, ini-option}}

<td>Sets final clock value to n.n</td>
</tr>

<tr>
<td><code>+KFI</code>n</td>{{#indexentry:+kfi}}

<td>Same as <code>Initial_Frame=</code>n</td>
</tr>

<tr>
<td><code>+KFF</code>n</td>{{#indexentry:+kff}}

<td>Same as <code>Final_Frame=</code>n</td>
</tr>

<tr>
<td><code>+KI</code>n.n</td>{{#indexentry:+ki}}

<td>Same as <code>Initial_Clock=</code>n.n</td>
</tr>

<tr>
<td><code>+KF</code>n.n</td>

<td>Same as <code>Final_Clock=</code>n.n</td>
</tr>
</table>

The internal animation loop relieves the user of the
task of generating complicated sets of batch files to invoke POV-Ray multiple
times with different settings. While the multitude of options may look
intimidating, the clever set of default values means that you will probably
only need to specify the <code>Final_Frame</code>=n or the
<code>+KFF</code>n option to specify the number of frames. All other
values may remain at their defaults.

Any <code>Final_Frame</code> setting other than -1 will trigger
POV-Ray's internal animation loop. For example <code>
Final_Frame=10</code> or <code>+KFF10</code> causes POV-Ray to render your
scene 10 times. If you specified <code>[[Reference:File_Output_Options#Output_File_Name|:Output_File_Name|Output_File_Name]]=file.tga</code>
then each frame would be output as <code>file01.tga</code>, <code>file02.tga</code>,
<code>file03.tga</code> etc. The number of zero-padded digits in the file name
depends upon the final frame number. For example <code>+KFF100</code> would
generate <code>file001.tga</code> through <code>file100.tga</code>. The frame
number may encroach upon the file name. On MS-DOS with an eight character limit,
<code>myscene.pov</code> would render to <code>mysce001.tga</code> through
<code>mysce100.tga</code>.

The default <code>Initial_Frame=1</code> will probably never have to be
changed. You would only change it if you were assembling a long animation
sequence in pieces. One scene might run from frame 1 to 50 and the next from
51 to 100. The <code>Initial_Frame</code>=n or <code>
+KFI</code>n option is for this purpose.
Note: If you wish to render a subset of frames such as 30 through 40 out
of a 1 to 100 animation, you should not change <code>Initial_Frame</code> or
<code>Final_Frame</code>. Instead you should use the subset commands
described in section [[Reference:Animation_Options#Subsets_of_Animation_Frames|Subsets of Animation Frames]].

Unlike some animation packages, the action in POV-Ray animated scenes does
not depend upon the integer frame numbers. Rather you should design your
scenes based upon the float identifier <code>[[Reference:Numeric_Expressions#Built-in_Variables|:clock|clock]]</code>. By default, the
clock value is 0.0 for the initial frame and 1.0 for the final frame. All
other frames are interpolated between these values. For example if your
object is supposed to rotate one full turn over the course of the animation,
you could specify <code>rotate 360*clock*y</code>. Then as clock runs from
0.0 to 1.0, the object rotates about the y-axis from 0 to 360 degrees.

The major advantage of this system is that you can render a 10 frame
animation or a 100 frame or 500 frame or 329 frame animation yet you still
get one full 360 degree rotation. Test renders of a few frames work exactly
like final renders of many frames.

In effect you define the motion over a continuous float valued parameter
(the clock) and you take discrete samples at some fixed intervals (the
frames). If you take a movie or video tape of a real scene it works the same
way. An object's actual motion depends only on time. It does not depend
on the frame rate of your camera.

Many users have already created scenes for POV-Ray 2 that expect clock
values over a range other than the default 0.0 to 1.0. For this reason we
provide the <code>Initial_Clock</code>=n.n
or <code>+KI</code>n.n and <code>Final_Clock</code>=n.n
or <code>+KF</code>n.n options. For example to run the clock from 25.0 to
75.0 you would specify <code>Initial_Clock=25.0</code> and <code>Final_Clock=75.0</code>.
Then the clock would be set to 25.0 for the initial frame and 75.0 for the final frame.
In-between frames would have clock values interpolated from 25.0 through 75.0 proportionally.

Users who are accustomed to using frame numbers rather than clock values
could specify <code> Initial_Clock=1.0</code> and <code>Final_Clock=10.0</code>
and <code>Frame_Final=10</code> for a 10 frame animation.

For new scenes, we recommend you do not change the <code>
Initial_Clock</code> or <code> Final_Clock</code> from their default 0.0 to
1.0 values. If you want the clock to vary over a different range than the
default 0.0 to 1.0, we recommend you handle this inside your scene file as
follows...
<pre>
#declare Start = 25.0;
#declare End = 75.0;
#declare My_Clock = Start+(End-Start)*clock;
</pre>

Then use <code>My_Clock</code> in the scene description. This keeps the
critical values 25.0 and 75.0 in your .pov file.
Note: Details concerning the inner workings of the animation loop
are in the section on shell-out operating system commands in section
[[Reference:Shell Command Options|Shell-out to Operating System]].

{{#indexentry:Animation, subsets of frames}}

==Subsets of Animation Frames==
<table width="100%" class="option-list">
<tr>
<td width="30%"><code>Subset_Start_Frame=</code>n{{#indexentry:Subset_Start_Frame}}{{#indexentry:Subset_Start_Frame, ini-option}}</td>

<td width="70%">Set subset starting frame to n</td>
</tr>

<tr>
<td><code>Subset_Start_Frame=</code>0.n</td>

<td>Set subset starting frame to n percent</td>
</tr>

<tr>
<td><code>Subset_End_Frame=</code>n{{#indexentry:Subset_End_Frame}}{{#indexentry:Subset_End_Frame, ini-option}}</td>

<td>Set subset ending frame to n</td>
</tr>

<tr>
<td><code>Subset_End_Frame=</code>0.n</td>

<td>Set subset ending frame to n percent</td>
</tr>

<tr>
<td><code>Frame_Step=</code>n{{#indexentry:Frame_Step}}{{#indexentry:Frame_Step, ini-option}}</td>
<td>Set the increment to the frame number, default to 1</td>
</tr>
<tr>
<td><code>+SF</code>0.n{{#indexentry:+sf}}</td>

<td>Same as <code>Subset_Start_Frame</code></td>
</tr>

<tr>
<td><code>+EF</code>0.n{{#indexentry:+ef}}</td>

<td>Same as <code>Subset_End_Frame</code></td>
</tr>
<tr>
<td><code>+STP</code>n{{#indexentry:+stp}}</td>
<td>Same as <code>Frame_Step</code></td>
</tr>
</table>

When creating a long animation, it may be handy to render only a portion
of the animation to see what it looks like. Suppose you have 100 frames but
only want to render frames 30 through 40. If you set <code>Initial_Frame=30</code>
and <code>Final_Frame=40</code> then the clock would vary from 0.0 to 1.0 from
frames 30 through 40 rather than 0.30 through 0.40 as it should. Therefore
you should leave <code> Initial_Frame=1</code> and <code>Final_Frame=100</code>
and use <code>Subset_Start_Frame=30</code> and <code>Subset_End_Frame=40</code>
to selectively render part of the scene. POV-Ray will then properly compute the
clock values.
Similarly, if you only want to render a tenth of the frames, you can use <code>Frame_Step=10</code> to jump over the nine non-rendered frames between the rendered frames. This option was inspired from megapov, but with two restrictions: only positive step value are supported (forward, no backward rendering) and the value is not available in the SDL

Usually you will specify the subset using the actual integer frame numbers
however an alternate form of the subset commands takes a float value in the
range 0.0 <=n.nnn <=1.0 which is interpreted as a fraction of
the whole animation. For example, <code> Subset_Start_Frame=0.333</code> and
<code>Subset_End_Frame=0.667</code> would render the middle 1/3rd of a
sequence regardless of the number of frames.

{{#indexentry:Animation, cyclic}}
==Cyclic Animation==
<table width="100%" class="option-list">
<tr>
<td width="30%"><code>Cyclic_Animation=</code>bool{{#indexentry:Cyclic_Animation}}</td>

<td width="70%">Turn cyclic animation on/off</td>
</tr>

<tr>
<td><code>+KC</code>{{#indexentry:+kc}}</td>

<td>Turn cyclic animation on</td>
</tr>

<tr>
<td><code>-KC</code>{{#indexentry:-kc}}</td>

<td>Turn cyclic animation off</td>
</tr>
</table>

Many computer animation sequences are designed to be run in a continuous
loop. Suppose you have an object that rotates exactly 360 degrees over the
course of your animation and you did <code>rotate 360*clock*y</code> to do
so. Both the first and last frames would be identical. Upon playback there
would be a brief one frame jerkiness. To eliminate this problem you need to
adjust the clock so that the last frame does not match the first. For example
a ten frame cyclic animation should not use clock 0.0 to 1.0. It should run
from 0.0 to 0.9 in 0.1 increments. However if you change to 20 frames it
should run from 0.0 to 0.95 in 0.05 increments. This complicates things
because you would have to change the final clock value every time you changed
<code>Final_Frame</code>. Setting <code>Cyclic_Animation=on</code> or using
<code>+KC</code> will cause POV-Ray to automatically adjust the final clock
value for cyclic animation regardless of how many total frames. The default
value for this setting is off.

{{#indexentry:Animation, field rendering}}
==Field Rendering==
<table width="100%" class="option-list">
<tr>
<td width="30%"><code>Field_Render=</code>bool{{#indexentry:Field_Render}}</td>

<td width="70%">Turn field rendering on/off</td>
</tr>

<tr>
<td><code>Odd_Field=</code>bool{{#indexentry:Odd_Field}}</td>

<td>Set odd field flag</td>
</tr>

<tr>
<td><code>+UF</code>{{#indexentry:+uf}}</td>

<td>Turn field rendering on</td>
</tr>

<tr>
<td><code>-UF</code>{{#indexentry:-uf}}</td>

<td>Turn field rendering off</td>
</tr>

<tr>
<td><code>+UO</code>{{#indexentry:+uo}}</td>

<td>Set odd field flag on</td>
</tr>

<tr>
<td><code>-UO</code>{{#indexentry:-uo}}</td>

<td>Set odd field flag off</td>
</tr>
</table>

Field rendering is sometimes used for animations when the animation is
being output for television. TVs only display alternate scan lines on each
vertical refresh. When each frame is being displayed the fields are
interlaced to give the impression of a higher resolution image. The even scan
lines make up the even field, and are drawn first (i.e. scan lines 0, 2, 4,
etc.), followed by the odd field, made up of the odd numbered scan lines are
drawn afterwards. If objects in an animation are moving quickly, their
position can change noticeably from one field to the next. As a result, it
may be desirable in these cases to have POV-Ray render alternate fields at
the actual field rate (which is twice the frame rate), rather than rendering
full frames at the normal frame rate. This would save a great deal of time
compared to rendering the entire animation at twice the frame rate, and then
only using half of each frame.

By default, field rendering is not used. Setting <code>
Field_Render=on</code> or using <code> +UF</code> will cause alternate frames
in an animation to be only the even or odd fields of an animation. By
default, the first frame is the even field, followed by the odd field. You
can have POV-Ray render the odd field first by specifying <code>
Odd_Field=on</code>, or by using the <code> +UO</code> switch.

@@ Line 35: / Line 35: @@
 Output_File_Name</code> for each frame.</p>
 {{#indexentry:Animation, internal loop}}
 <table width="100%" class="option-list">
 <tr>
@@ Line 153: / Line 152: @@
 <!--<linkto "Shell Command Options">Shell Command Options</linkto>--->[[Reference:Shell Command Options|Shell-out to Operating System]].</p>
 {{#indexentry:Animation, subsets of frames}}
 <table width="100%" class="option-list">
 <tr>
@@ Line 220: / Line 218: @@
 sequence regardless of the number of frames.</p>
 {{#indexentry:Animation, cyclic}}
 <table width="100%" class="option-list">
 <tr>
@@ Line 257: / Line 255: @@
 value for this setting is off.</p>
 {{#indexentry:Animation, field rendering}}
 <p class="Note"><strong>Note:</strong> {{Change}} these items are <em>deprecated</em> as of version 3.7</p>
 <table width="100%" class="option-list">

@@ Line 14: / Line 14: @@
 <td width="30%"><code>Clock=</code>n.n</td>
-<td width="70%">Sets <code>[[Reference:Numeric_Expressions#Built-in_Variables|:clock|clock]]</code> float identifier to n.n</td>
+<td width="70%">Sets <code>[[Reference:Numeric Expressions#Built-in Variables|:clock|clock]]</code> float identifier to n.n</td>
 </tr>
@@ Line 35: / Line 35: @@
 {{#indexentry:Animation, internal loop}}
 ==Internal Animation Loop==
 <table width="100%" class="option-list">
@@ Line 93: / Line 94: @@
 <code>+KFF</code><em>n</em> option to specify the number of frames. All other
 values may remain at their defaults.</p>
-<p>Any <code>Final_Frame</code> setting other than -1 will trigger POV-Ray's internal animation loop. For example <code>Final_Frame=10</code> or <code>+KFF10</code> causes POV-Ray to render your scene 10 times. If you specified <code>[[Reference:File_Output_Options#Output_File_Name|:Output_File_Name|Output_File_Name]]=file.tga</code> then each frame would be output as <code>file01.tga</code>, <code>file02.tga</code>, <code>file03.tga</code> etc. The number of zero-padded digits in the file name depends upon the final frame number. For example <code>+KFF100</code> would generate <code>file001.tga</code> through <code>file100.tga</code>. The frame number may encroach upon the file name. On MS-DOS with an eight character limit, <code>myscene.pov</code> would render to <code>mysce001.tga</code> through
+<p>Any <code>Final_Frame</code> setting other than -1 will trigger POV-Ray's internal animation loop. For example <code>Final_Frame=10</code> or <code>+KFF10</code> causes POV-Ray to render your scene 10 times. If you specified <code>[[Reference:File Output Options#Output File Name|:Output_File_Name|Output_File_Name]]=file.tga</code> then each frame would be output as <code>file01.tga</code>, <code>file02.tga</code>, <code>file03.tga</code> etc. The number of zero-padded digits in the file name depends upon the final frame number. For example <code>+KFF100</code> would generate <code>file001.tga</code> through <code>file100.tga</code>. The frame number may encroach upon the file name. On MS-DOS with an eight character limit, <code>myscene.pov</code> would render to <code>mysce001.tga</code> through
 <code>mysce100.tga</code>.</p>
 <p>
@@ Line 104: / Line 105: @@
 of a 1 to 100 animation, you should not change <code>Initial_Frame</code> or
 <code>Final_Frame</code>. Instead you should use the subset commands
-described in section <!--<linkto "Subsets of Animation Frames">Subsets of Animation Frames</linkto>--->[[Reference:Animation_Options#Subsets_of_Animation_Frames|Subsets of Animation Frames]].</p>
+described in section <!--<linkto "Subsets of Animation Frames">Subsets of Animation Frames</linkto>--->[[Reference:Animation Options#Subsets of Animation Frames|Subsets of Animation Frames]].</p>
 <p>
 Unlike some animation packages, the action in POV-Ray animated scenes does
 not depend upon the integer frame numbers. Rather you should design your
-scenes based upon the float identifier <code>[[Reference:Numeric_Expressions#Built-in_Variables|:clock|clock]]</code>. By default, the clock value is 0.0 for the initial frame and 1.0 for the final frame. All other frames are interpolated between these values. For example if your object is supposed to rotate one full turn over the course of the animation, you could specify <code>rotate 360*clock*y</code>. Then as clock runs from 0.0 to 1.0, the object rotates about the y-axis from 0 to 360 degrees.</p>
+scenes based upon the float identifier <code>[[Reference:Numeric Expressions#Built-in Variables|:clock|clock]]</code>. By default, the clock value is 0.0 for the initial frame and 1.0 for the final frame. All other frames are interpolated between these values. For example if your object is supposed to rotate one full turn over the course of the animation, you could specify <code>rotate 360*clock*y</code>. Then as clock runs from 0.0 to 1.0, the object rotates about the y-axis from 0 to 360 degrees.</p>
 <p>
 The major advantage of this system is that you can render a 10 frame

@@ Line 93: / Line 93: @@
 <code>+KFF</code><em>n</em> option to specify the number of frames. All other
 values may remain at their defaults.</p>
-<p>
+<p>Any <code>Final_Frame</code> setting other than -1 will trigger POV-Ray's internal animation loop. For example <code>Final_Frame=10</code> or <code>+KFF10</code> causes POV-Ray to render your scene 10 times. If you specified <code>[[Reference:File_Output_Options#Output_File_Name|:Output_File_Name|Output_File_Name]]=file.tga</code> then each frame would be output as <code>file01.tga</code>, <code>file02.tga</code>, <code>file03.tga</code> etc. The number of zero-padded digits in the file name depends upon the final frame number. For example <code>+KFF100</code> would generate <code>file001.tga</code> through <code>file100.tga</code>. The frame number may encroach upon the file name. On MS-DOS with an eight character limit, <code>myscene.pov</code> would render to <code>mysce001.tga</code> through
 <code>mysce100.tga</code>.</p>
 <p>
@@ Line 118: / Line 108: @@
 Unlike some animation packages, the action in POV-Ray animated scenes does
 not depend upon the integer frame numbers. Rather you should design your
-scenes based upon the float identifier <code>[[Reference:Numeric_Expressions#Built-in_Variables|:clock|clock]]</code>. By default, the
+scenes based upon the float identifier <code>[[Reference:Numeric_Expressions#Built-in_Variables|:clock|clock]]</code>. By default, the clock value is 0.0 for the initial frame and 1.0 for the final frame. All other frames are interpolated between these values. For example if your object is supposed to rotate one full turn over the course of the animation, you could specify <code>rotate 360*clock*y</code>. Then as clock runs from 0.0 to 1.0, the object rotates about the y-axis from 0 to 360 degrees.</p>
 <p>
 The major advantage of this system is that you can render a 10 frame

@@ Line 1: / Line 1: @@
 [[Category:Command-Line and INI-File Options]]
-{{#indexentry:Animation, options|Options, animation}}
+{{#indexentry:Animation, options}}
 <p>Internal animation loop, automatic output file name numbering and the
 ability to shell out to the operating system to external utilities which can

@@ Line 7: / Line 7: @@
 create animations without the internal loop.</p>
 {{#indexentry:Animation, external loop}}
 {{#indexentry:+k}}
 <table width="100%" class="option-list">
 <tr>

← Older revision	Revision as of 18:09, 17 July 2012
(No difference)

← Older revision	Revision as of 19:05, 15 March 2012
(No difference)