# Blender 3D: Noob to Pro/Creating Basic Water animation

|previous=Basic Animation/Bounce
}}
```
!A low resolution, high viscosity fluid
test

## Water and Other Fluids

Water is without a doubt one of the most important compounds in our
lives; It covers about 75% of the earth and is therefore incredibly
important in quite a few Blender animations. Wouldn\'t it be great if we
could get an accurate physical representation of this liquid in Blender?
We can, using a tool called Fluid Simulation. This tool looks
unnervingly complex at first glance, but this tutorial should clear it
up for you. At least to a basic level.

## The Domain

One can imagine how much time it would take Blender3D to think about
everything in the infinite space of a 3D world in terms of fluid objects
and deflection, so we obviously need to cut down on that size. Create a
fairly large cube. This will eventually be set as the volume in which
all of the fluid simulation occurs. Don\'t make it too large, but not
too small either, let\'s say 10 times bigger. With this cube selected,
go to to the Physics context
![](Blender255PhysicsContextButton.png "Blender255PhysicsContextButton.png")
of the Properties window. Find the button that says \"Fluid\", and click
the \"Fluid\" button to enable the function. Set type to \"Domain\". All
the fluid physics will be calculated inside this cube. Also in that tab,
you\'ll see 3 sub-sections, \"Fluid World\", \"Fluid Boundary\" and
\"Fluid Particles\". Each one opens a different set of settings. These
will be explained as they become important.

Under \"Time\" you can adjust how many seconds the fluid animation will
take. Due to this you should change the \"End\" frame to \"96\", under
the \"Timeline\", because the standard setting is \"4\". You can also
change it how you like.

To make the other objects go into the \"Wireframe\" viewport.

!Domain\
\
\
\
\
\
\
\
\
\

## The Fluid

As a basic start up for your experiments with fluid simulation, I am
going to take you through a small demo in which we drop an object into a
pool of water, creating a splash. To do this, we need a fluid object and
an obstacle object. For the fluid, create another cube, scaled down to
cover the bottom of your domain. Make a rectangle, that hovers just
inside the domain and is half as high as the domain. Enable this object
in fluid simulation also and set type to \"fluid\". When we start to
bake the fluids, this will be set up as your liquid.

Let us go over what you have now. You have your starting cube, with
fluid physics and type \"domain\", and will be referred to as
\"Domain\". Inside this is the rectangle that will cover the bottom of
your Domain , which is the liquid. The liquid will be a different object
with the type \"Fluid\".

!Fluid\
\
\
\
\
\
\
\
\
\

## The Obstacle

Create a third object which we will call \"Obstacle\". This will be the
object dropped into the water, and will be described further in the
explanation. Give it an IPO/Animation to drop into the water, and enable
it as \--you guessed it\-- an obstacle (click the \"fluid\" button, in
physics, and set type to \"obstacle\").

Set up the animation in the front/side views, not the top view. The
z-axis is where gravity works.

!Obstacle\
\
\
\
\
\
\
\
\
\

## Baking Fluids

Now we get to see what it all looks like. Select the domain object, and
find the big button that says \"BAKE\" under \"Physics\" - \"Fluid\". If
you want to use a bake again, don\'t choose a temporary location,
otherwise you\'ll have to bake it all over again. Press it. Be patient,
blender has to bake this simulation, something like it would render the
final product. The loading bar of this baking will stay in the bar at
the top of the screen with the blender logo. If at any time you feel
that you want to abort this process, press \"Esc\". Once the bake is
finished, click under the \"Timeline\" on the play button. You should be
able to view the full simulation.

!Bake\
\
\
\
\
\
\
\
\
\

## Finishing touch

Blender will make your water its default opaque grey, unless you set its
color. A good way to make realistic, clear water (as well as glass for
that matter) is to edit the color, then apply a simple mirror effect
plus transparency effect. After your water has rendered, select the
domain in object mode. This selects the liquid in the frame you have
just added. in the \"Materials\" tab (if when you click on this, the
colors settings are not up, just press add new under the only panel
there). Go to the \"Mirror\" section, play around with the settings
until you get what you fancy. Suitable settings include Reflectivity to
0.1 for water, 0.15 for glass, set depth to 7; Under the Transparency
section, click on Raytrace and set IOR to 1.3 for water, 1.5 for glass;
Then set the Alpha value to 0.1 while adding an appropriate color under
the \"Diffuse\" section, like: \"6279E7\". I should do the same for the
\"Fluid\"

!Simulation\
\
\
\
\
\
\
\
\
\

## Other Fluid Objects

There are other incredibly useful types of fluid objects like \"inflow\"
and \"outflow\". The both of these do exactly what they sound like.
Inflow objects pour more fluid into the scene, and outflow objects drain
it away.


# Blender 3D: Noob to Pro/Flying Through A Canyon

|previous=Creating Basic Water animation
}}
```
## Creating the Canyon

### Forming from Textures

1.  Open up a new Blender file and erase the default cube with

2.  Add a grid and change the subdivisions to 100 for both X and Y.

```{=html}
<!-- -->
```
1.  Scale the canyon up to 5 times its current size

(Do this by either hitting  and typing
in 5, or hitting  while holding
 to snap and scale your mesh 5 times.

At this point your mesh should look like something like the picture
below.

### Texturing, Shading, and Deforming Your Mesh

-   Go to the Texture tab next to the Materials, and click *New*.
    -   This texture will be used to create our canyon, so give it an
        appropriate name. In this tutorial, \"Canyon\" was used.
-   Select the Texture Type to be Wood
-   If there is a Checkbox next to \"Canyon\" in the Texture tab,
    uncheck it.

We will now displace the vertices based on the texture.

-   Click on the Modifiers tab on the Properties panel (spanner icon).
-   Click the *Add Modifier* pop-up menu and select \"Displace\".
-   Select your \"Canyon\" texture for the displacement.
    -   Go into Object Mode. Notice that the vertices have been
        displaced! (To see the results better, make sure you\'re in
        Solid Mode) However, the material is very jagged. This is
        because Blender is preserving the original faces on the
        underlying material, and the original faces don\'t run in the
        same direction as the grooves the wood material has created.

**Noob Note:** This will also work with an image texture, i.e. using an
image as a texture. Tested using NASA\'s Blue marble topographic
pictures. Go to the end of this tutorial for additional projects.

Your Mesh should now look something like the picture below.

### Improving the Look

Now to make the canyon more interesting:

-   Go back to the textures tab, under the Wood tab deselect Bands and
    select RingNoise. Keep the default options for the moment.
-   You will now see a \"rippling\" texture. But it isn\'t a canyon yet.

**Note:** If you go into Edit mode (Tab), and select all vertices, then
scale to 0.2 of the original size. after this should leave Edit Mode
into Object Mode, and scale the Object (as a whole) up to 10.0 of the
size. What will occur is that you\'ll pack the vertices closer to each
other, but not the texture. Then, you would have taken the object as a
whole (including the Texture) and up-scaled it. This is the difference
between Scale in Edit Mode and Scale in Object Mode. Don\'t do it!

-   You should now have a semi-boring canyon, but it does have circuits
    which the camera can float around in.
-   To make the Canyon more interesting, play around with the Texture
    values for Wood. I chose the values Noise Size: 1.0 and Turbulence:
    15.00 as they produced a somewhat interesting outer ring.
-   You may also want to play around the Deform modifier settings,
    especially *Strength* which changes the strength of the
    deformations.
-   When you are happy with your mesh, press the *Apply* button under
    the Deform modifier.
    -   The displacements are now permanently baked into the Mesh, and
        the result should be something like the picture below.

### Eliminating the Unneeded

-   We will now reduce the number of vertices. Go into Modifiers, and
    add Decimate. The mesh will appear to change slightly, but it
    hasn\'t, except that 4-vertices faces have been triangulated
-   Add another Modifer, Sub Surf, and make sure that the Levels is just
    1
-   Under the Decimate, slowly reduce the ratio and watch the Mesh. Very
    tiny mesh details will be changed but the Decimate modifier will
    keep the shape while reducing vertices.
-   I got to 0.07 on my mesh before I decided the detail was getting too
    low. Remember you will be flying through the canyon, not over it, so
    the detail on the walls of the canyon is more important.
-   Hit apply to bake the reduced vertice count into the Mesh. Smaller
    vertice counts will make rendering faster.
-   Increase the number of levels on your Sub Surf modifer and take a
    good look, you have just created a canyon! You may reduce the levels
    or remove the Sub Surf entirely afterwards.

## Coloring the Canyon

### A Rocky Material

This is one method to create a rocky wall. The result isn\'t
particularly realistic but it is easy to make. Creating materials is a
difficult practice, and the first step is to know what you\'re trying to
recreate, perhaps by using actual photographs.

-   Create a new material for the cliff
-   In the Specular panel under the Materials tab, set the Intensity
    value to 0.132 (our cliff isn\'t particularly shiny) and Hardness to
    20.
-   Under the Textures tab, add a new texture in the first slot.
    -   Give this texture the Marble texture type. Under the Marble
        options, select Hard and set the Noise Depth to 1 and Turbulence
        to 1.7.
    -   Under the Colors tab, activate *Ramp*. The first colorstop
        should be white with an alpha of 0, leave the second as it is.
    -   This is meant to give our primitive rock a textured appearance
-   In the second texture slot, add another texture.
    -   Set this type to Clouds, under the *Mapping* options set the X,
        Y, and Z sizes to .025, under the cloud options select a noise
        depth of 2 and activate Hard Noise.
    -   This one will recreate some bumpiness and small inconsistencies
        in the rock
-   In the third slot, add another texture
    -   Set the type to Clouds
    -   In the Colors tab, modify the colors to go from Black, 0 Alpha,
        to a Brown of your choosing, 0.750 Alpha. Reposition the second
        color to Pos 0.820
    -   This Texture will simulate dirt on the Canyon
-   You will definitely want to do a render now. Reposition the camera
    and lights, and adjust render options to make for a fast render
-   Go into Materials, then the textures tab and select the first Clouds
    texture you entered (should be 3rd on the list if you did not delete
    the Wood texture used earlier).
-   With that selected, under the influence section, uncheck the Color,
    and check normal. Set the Normal value to 2.0.
    -   What we have just done is set the second texture not to affect
        color, but to affect the angle of the normal in a render. This
        can be used to reproduce jagged edges on flat surfaces, or waves
        in water
-   Now, select the Marble texture again. Under the Map Input, adjust
    the sizeX, sizeY, and sizeZ values to 5.0.
-   Change the Z size under mapping to 5.0 from the second cloud
    texture.
    -   You will want to render here, adjust the values as desired. For
        more layers vertically, increase the sizeZ value
-   You should now have an unrealistic, but sort of rocky Canyon wall.

### Lighting the cliff

-   Remove all existing lights
-   Creating a new light with the type of \"Hemi\". Center it over our
    cliffs, and use Scale (s) to scale it down.
-   Create another light, with the type of \"Sun\". Position it where
    you want (position doesn\'t matter with Sun), and use Rotate (r) to
    position its Ray at the Angle you desire.
    -   In this example, the Sun was more of an evening Sun. Its light
        is at a 45 degree angle on one side. This creates some Canyon
        walls light, some dark.
-   Position your camera and adjust the Energy values of your Hemi and
    your Sun. The Hemi will light up everything, its an easy way to give
    light to canyon walls that would otherwise be completely black. As a
    starting point, set your Hemi value at 0.4 and your Sun value at 1.5
    and observe how that looks from a few angles. Make adjustments if
    you desire.

```{=html}
<!-- -->
```
-   Finally change for all the three textures the Mapping - Coordinates
    to \"Generated\" instead of \"UV\"

## Guide the camera through the canyon

The last step is to guide the camera through the canyon.

1.  Click on the camera in the Outliner.
2.  Click on Num0 and zoom a bit, then lock camera to view.
3.  Go to keyframe 1 and set a locrotscale keyframe.
4.  Click on the red dot under the Timeline, which will keyframe every
    movement.
5.  For simple keyframing set the Framerate to 8 FPS and set the End
    frame on \"1000\" then hit the play button under the Timeline.
6.  Now fly with shift+F through the canyon.
7.  After this set the frame rate back at 24 FPS and watch and see your
    beautiful simulation, which will possibly take too long to render.

## Additional projects

1.  Using NASA\'s topographic image map at
    <http://earthobservatory.nasa.gov/Features/BlueMarble/BlueMarble_2002.php>

You have the option of selecting a small portion of your selected
topographic map or you can map the entire 360x180 degree panoramic map
onto a sphere. Refer to UV Mapping tutorial.

If you just select a small portion of the map of the world(cropping),
note the resolution of your cropped image. Create a basic plane and do
not scale it yet. Sub divide as many as required to match the resolution
of your image. This is in order to get the most out of the topographic
image. If you don\'t bother, this is not essential.

Then apply the texture. Choose texture of type \"image\" and do not
disable this texture. NASA\'s topographic pictures also come in a
colourful form but shaded to indicate heights. The reason why you leave
the scaling to the last is that the texture is set to map onto the basic
plane size of 2x2 units. If you increase this, the textures will be
repeated. Adjust the strength level to a suitable level. The default 1
is too large.

\


# Blender 3D: Noob to Pro/Using the sequencer to compile frames into an animation

|previous=Flying Through A Canyon
}}
```
## Preamble

When you render an animation, often it\'s a good idea to render the
individual frames and then compile them into the animation. This has
several benefits over rendering directly to a movie file. Some of them
are these:

-   -   If you discover a mistake in the render, you can modify sections
        of the animation and rerender those frames without having to
        rerender the whole animation.
    -   If the render crashes because the power went out or, (psst),
        blender crashed, you can pick up the render at the last rendered
        frame without having to rerender the whole animation

## Tutorial

-   Open your animation in blender

Begin by opening blender to an animation that is ready to be rendered.

-   If you don\'t have one and don\'t want to wait to long, just
    download the demo file from blender.org For
    You

```{=html}
<!-- -->
```
-   The output format should stay PNG. Though you can use any image
    format you want, I recommend PNG because it is lossless format.

```{=html}
<!-- -->
```
-   Set the file output location.

Set the location on your file system where you want all the frames to be
saved to.

-   Set Endframe to match the animation

If you animated 500 frames, set the end frame to that same number. the
default is 250.

-   Render the animation!

Simply press the \"Render\" button under the render tab.

-   For \"For You\", you only need to click Num0 and go to \"Render\" in
    the menu bar. Then click on \"OpenGL Render Animation\". For
    exercise, 100 frames must be enough.

------------------------------------------------------------------------

## Use the Sequencer to compile the images into a movie file

-   Open a new blender and delete everything except the camera.

```{=html}
<!-- -->
```
-   Change the 3d window into the \"Video Sequencer Editor\" window.

!video Sequence
Editor\
\
\
\
\
\
\
\
\
\

-   Add the images to the sequencer.

On the bottom of the sequencer window click Add\>\>Image then browse to
the location where you saved the images, Press A to select all the
images and finally press "Add Image Strip\" on the top-right.

-   Set final movie format.
-   Set the location that the movie will be saved to by changing the
    output path.

!Format\
\
\
\
\
\
\
\
\
\

-   Change the End Frame.

!Ready for
Render\
\
\
\
\
\
\
\
\
\

-   Render!

Just Press the Render \"Animation\" button and wait a few seconds till
it\'s done. Browse to the location you saved your movie and enjoy the
animation.


# Blender 3D: Noob to Pro/Further Rendering Options

|previous=Using the sequencer to compile frames into an animation
}}
```
In previous units on renderer settings, you learned about

-   Basic settings, and
-   Animation rendering.

Here we will describe some more renderer settings that can be useful in
certain circumstances.

## Stamping

![](Blender268RenderContextStampOptions.png "Blender268RenderContextStampOptions.png")
The "Stamp" panel in the Render
![](Blender255RenderContextButton.png "Blender255RenderContextButton.png")
context provides options for placing descriptive text on top of each
rendered frame. The topmost checkbox enables/disables stamping (off by
default), while the other checkboxes control the precise information to
include, and you can even specify the text and background colour and
font size. The information is inserted at the corners of the image, so
it can be included in production renders that get appropriately cropped
as part of the post-production process. **Note:** In blender 2.76,
you\'ll find it under Metadata. You\'ll have to check Stamp Output.

## Toon Renders

![](Blender268RenderContextPostProcOptions.png "Blender268RenderContextPostProcOptions.png")
Blender has long had an option for doing simplified "toon"
(cartoon-style outlined) renders. In the Render
![](Blender255RenderContextButton.png "Blender255RenderContextButton.png")
context, look for the "Post Processing" panel and check the "Edge" box.
You will also have to set up the lighting and materials for your objects
to give a more flat-shaded look.

A more powerful set of options for doing this sort of thing is available
with
Freestyle,
which you will learn about
later.

## Clay Renders

There is sometimes a need to render a scene without detailed materials
and textures, just to see what the object shapes look like. In the
Render Layers
![](Blender267RenderLayersContextButton.png "Blender267RenderLayersContextButton.png")
context, there is an option to override all lighting and materials for
objects in the layer with a particular light group and a particular
material. It is common to use a plain diffuse, colourless grey material
for this purpose, making all the objects look like they are made out of
clay, hence the name.

## Transparent Backgrounds

Blender by default provides a "sky" or background for your rendered
scene; settings for this can be controlled in the World
![](Blender255WorldContextButton.png "Blender255WorldContextButton.png")
context.

Sometimes you don't want such a background at all; you simply want the
objects in your scene set against a *transparent* background. So, for
example, if you insert the image in a Web page, the scene is displayed
against the page background, rather than its own image background.

The way to do this is quite simple:

-   Choose to render the Sky as Transparent. In the Render
    ![](Blender255RenderContextButton.png "Blender255RenderContextButton.png")
    context, look for the Shading panel, where there is a popup menu
    labelled "Alpha:", with items "Sky" and "Transparent". Change this
    from its default "Sky" to "Transparent". You have to do this before
    rendering the image.
-   When saving the rendered image, choose a file format (in the Output
    panel in the Render
    ![](Blender255RenderContextButton.png "Blender255RenderContextButton.png")
    context) that includes an *alpha
    channel*; for example, PNG allows for
    this, but JPEG does not. With such a format chosen, you further have
    to remember to select the "RGBA" button, not "RGB", otherwise the
    transparent areas will simply be filled with black.


# Blender 3D: Noob to Pro/Particle Systems

|previous=Further Rendering Options
}}
```
## Introduction

Particle systems are used to simulate large amounts of small moving
objects, creating phenomena of higher order like fire, dust, clouds,
smoke, or fur, grass and other strand based objects. You may also use
other objects as a visualization of particles.

Before you start with the tutorials, you should at least take a brief
overview about the very extensive documentation
pages of
the particle system. You will find every single parameter explained in
the manual if you have the desire to delve deeper \...

Don\'t forget: particles alone don\'t do any magic. They are only a
placeholder for something nice to view. You have to take care of the
visualization also, and that is usually the harder part than to create
the particle system.

## The very first particle system

### Creating a particle system

framed\|**Image 1a:** Where to create a new particle
system
framed\|right\|**Image 1b:** The very first particle
system To create a
particle system:

-   Create a mesh object to be the "parent" (source) of the particles
    (only mesh objects can emit particles). Let's use a simple plane to
    start with.
-   select the object
-   change to the Particles
    ![](Blender255ParticlesContextButton.png "Blender255ParticlesContextButton.png")
    tab in the Object Properties window
-   click on the "+" button (**Image. 1a**)

Voila, your first particle system (**Image. 1b**)! It doesn\'t do
anything useful now, but we\'re going to change that on the following
pages.

-   To see the particles, you must start the animation running by
    pressing . You will see particles
    appear and fall from the plane. Press
     to stop the animation; you return
    to frame 1. The particle movement is cached (stored), so if you play
    your animation again it will go faster (well, you won\'t notice any
    difference in this simple case).
-   If you want to stop the animation in the current frame, press
     while it is running instead of
    .
-   The shortcut for returning to the first frame is
    )
-   To see the particles even better change to wireframe mode
    (),

If you change anything in your particle system you always have to return
to frame 1, to recalculate the system from the start.

Use the *timeline* window along the bottom of the screen to change
easily between frames.

### Changing properties of the system

framed\|**Image 2a:** Particles emitted in the direction of the face
normal of the plane
Some important settings, from the "Emission" panel:

-   *Number:* the total number of particles; increase this to 5000
-   *Start:* and *End:* the start and end frame of the emission
-   *Lifetime:* the lifetime in frames of the particles

And in the "Velocity" panel are settings that combine to determine the
initial velocity of the particles:

-   *Normal:* a velocity component in the direction of the face normal
    (if emitted from faces)
-   *Tangent:* a velocity component parallel to the face
-   *Rotation:* controls the direction of the tangent velocity component
-   *Emitter Object X/Y/Z*: a velocity component oriented in the
    object's coordinate system
-   *Object:* a multiplier that imparts some proportion of the object
    velocity to the particles (try moving the object around with a
    nonzero value for this field to see its effect)
-   *Random:* a random contribution to the object velocity

Initially, the plane has its face normal oriented upwards. However, it
probably looks like the particles are emitted downwards. This is because
the initial normal velocity of 1.0 is quite small compared to the force
of gravity (which is on by default). Try increasing it to something like
10.0, and when you rerun the animation, you should see the particles
rise quite high above the plane before falling down again.

If you render a frame with particles showing, you will see the particles
appear as white blobs. This is the default *Halo* rendering of the
particles.

### Changing the material of the particles

framed\|right\|**Image 3a:** The first simple *Halo*
material.

-   Switch the Properties window to the Materials
    ![](Blender255MaterialContextButton.png "Blender255MaterialContextButton.png")
    tab and create a new material for the plane.
-   Change the material type to *Halo*. (see also the Manual on
    Halos).
    Halos are a post rendering effect, that is applied after the scene
    is finished. So halos can\'t shed any lights on other objects, they
    are not rendered behind *RayTransp* materials (like glass).

framed\|**Image 3b:** Our first particle system rendered in frame
68

-   Set the color to deep blue (RGB: 0/0/1)
-   *Size:* 0.05 so each halo is quite small.
-   *Hardness:* 127 so that each halo has the maximum sharp edge
-   *Add:* 0.5 so that the brightness increases where several halos
    overlap

Set the world color to black and render (**Img. 3b**). Nothing special
till now, but that will change soon. So proceed to the next page, where
we\'re going to make some fire.


# Blender 3D: Noob to Pro/Making Fire

|previous=Particle Systems
}}
```
framed\|**Figure 1:** My idea of particle
fire. We\'re going to
create a camp fire with a simple particle system. This tutorial is based
on the method described in the Blender
Manual.
The result of this tutorial is shown in **Fig. 1**, the Blend-File is
included at the bottom of this page.

If you need more realistic looking fire, you should use the method
described in BlenderArt Magazine No.
16, though that method is more
advanced and uses Compositing Nodes heavily.

The starting point of the tutorial is how fire behaves physically. The
flames are made of hot gases. These accelerate upwards due to their
lower density in contrast to the cooler air in the environment. Flames
are in the middle hot and bright, to the outside they are darker.

## The particle system

!**Figure 2a:** A simple
scene{width="300"}
I\'ve created the usual scene with some stones and a few pieces of wood
(the wood is by courtesy of Teeth). (**Fig. 2a**).

  ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  **Noob note:** I made the stones by adding an Icosphere of 3 subdivisions, and then used the proportional edit falloff (**OKey**) with the random falloff mode. And then subdivide and smooth.
  **Noob note 2:** For the wood I used a modified Plane with an Image texture created with **GIMP**
  ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

-   Add a *Plane* in the middle of the stones.

This will become the particle emitter.

-   Rename the *Plane* object to \"Emitter\".

If you use good names you will find it much easier to orientate yourself
in your scene later. Having 100 objects named \"Cube.something\" will
make it very difficult to quickly select a desired object.

-   Subdivide the plane once in *Edit* mode.
-   Change the shape of the plane, so that it\'s shape equals the base
    of the fire.
-   Change to object mode.

framed\|**Figure 2b:** The particle
system

-   Change to the *Particle* buttons of the *Object* buttons.
-   Create a particle systems (*Add New* in the *Particle System*
    panel - and make sure the plane is selected!).
-   *Type: Emitter* The plane emits the particles.
    -   *Amount:* 9000 The total amount of particles.
    -   *Sta:* -45 The simulation shall start before the rendering, to
        have a fully developed flame in the first frame.
    -   *End:* 200 The simulation shall last 200 frames - here: the
        particles are emitted till frame 200.
    -   *Life:* 16.6 I\'ve adjusted the lifetime of the particles to
        their speed. Both parameters together regulate the height of the
        flame.
    -   *Rand:* 0.5 The lifetime is changed randomly.
-   *Emit from:*
    -   *Random*
    -   *Faces*
    -   *Even*
    -   *Random*

This creates particles with a random distribution on the faces of the
emitter object.

The movement of the particles is controlled with particle physics. You
set the *Initial Velocity* and let the physics do the rest.

-   *Normal:* -0.099 The particles are emitted slightly against the
    direction of the face normal. This leads to a bit wider fire at the
    base.
-   *Random:* 0.014 This creates a random start velocity as well in
    speed as in direction (you could use a texture to randomize only the
    speed, see the discussion page for that).

After you have given the particles an initial velocity they are moved by
forces.

-   *AccZ:* 2.57 A force in positive Z direction (upwards).

-   *Drag:* 0.1 Air drag decelerates the particles.
-   *Brown:* 1.99 Random movement simulates agitated air movement.

!**Figure 2c:** Particles without
material{width="200"}
The particle system is finished. Until now is doesn\'t look like much
(see the white Blob in **Fig. 2c**). Therefore the emitter will get a
material, this material will be animated.

## Material

framed\|**Figure 3a:** Material for the emitter
object.

-   Create a new material for the emitter, call the material *Flames*.
-   Activate the *Halo* button in the *Links and Pipeline* panel. Else
    we couldn\'t set the particle parameters. The particles would be
    rendered with the default Halo values.
-   *Halo* color: 1/0/0 (red)
-   *Alpha:* 0.8 The particles shall always be a bit transparent.
-   *HaloSize:* 0.132 I wanted many, but fairly small particles.
-   *Hard:* 45 The transition from fully transparent to fully opaque.
-   *Add:* 0.875 Several *Halos* over each other combine their power.
    This makes the fire in the center really bright.
-   *HaloTex:* A Halo can bear an individual texture, but only the
    texture in the first texture slot is evaluated.

To give the Halo a bit more structure, give it a texture:

-   Add a new texture in the first texture slot.
-   *Map To:*
    -   *Col*
    -   Color: Bright yellow (1/1/0.664)

!**Figure 3b:** Adjusted
texture{width="600"}

-   Use an adjusted *Clouds* texture with a *NoiseSize* of 0.6.

### Animation of the particle material

framed\|**Figure 3c:** Animation of the *Alpha*
value
The particles \"pop\" into life and vanish suddenly. We should change
that. Therefore we\'re going to animate the *Alpha* value of the
particles.

-   Make sure the material buttons are visible in the buttons window.
-   Change to frame 21, move the mouse cursor over the button window and
    press **I**-\>*Alpha*. This is going to be the maximum visibility of
    the particles.
-   Change to frame 1. Change the *Alpha* value to 0 and insert the next
    key.
-   Change to frame 100. Change the *Alpha* value to 0 again and insert
    the third key.

If you want to see the IPO curve in the *IPO Editor* window you must
change the *IPO Type* selector in the window header from *Object* to
*Material*.

The *Alpha* value therefore changes during the individual lifetime of
each particle from 0 to 0.8 and back to 0 (**Fig. 3c**).

## Rendering

Our particle animation is finished.

-   Change the end frame in the *Anim* panel of the rendering Buttons to
    200 and click on *Anim*.

**Note: If after rendering your particles are too small, such that the
fire doesn\'t look realistic, try increasing the *Halo size* slightly. I
used 0.300 instead of 0.132**

To actually let the fire glow you have to use one or more lamps and
animate them as well. But that would be part of another tutorial \...


# Blender 3D: Noob to Pro/Furry

|previous=Making Fire
}}
```
*There is an older version of this page created with Blender
v2.40.*

(NOTE: **New:** marks  Notes
added for newer versions. I\'m not an expert but they seem to work.)

!**Figure 1:** The result of this tutorial: some furry
thing{width="300"}

This tutorial deals with fur, i.e. lots of relatively short hairs
covering a body. We will use particles to create the fur, and discuss a
few aspects here:

-   How to determine the length and the thickness of the hair.
-   How to determine the place to grow the hair.
-   How to color hair.
-   How to render efficiently.

The particle system is far too complex to show more than one method in
this tutorial. You can achieve many of the same effects shown here in
different ways.

## The emitter

framed\|**Figure 2a:** Adding a particle
system.

-   Remove the cube.
-   Add an *UVSphere*. This will become our emitter.
-   Change to the *Particle* buttons in the *Object* buttons
    (**Fig. 2a**). **New:** looks like !20
    px in newer versions.
-   Click on *Add New*. **New**: Click on !20
    px in newer versions.
-   Rename the particle system to \"Fur\".
-   Change the particle system type to *Hair*.

A *Hair* particle system has a lot of specialties, the most important
thing is that we can edit the particle \"motion\" by hand if we want to.
Apart from that normal particle physics apply, so everything a particle
does hair can do also and vice versa. A particle hair shows the way of
the particle during its lifetime at once. To do that efficiently not
every single frame is rendered as a point, but a certain number of
control points are calculated. Between these control points there will
be drawn an interpolated path. The number of control points is the
number of segments + 1.

framed\|**Figure 2b:** Particle system
settings For
fur you need lot\'s of particles, like 1.000.000 upwards. This will hurt
us badly if we have to deal with so many particles in the 3D window and
want to render it. Therefore, we will create the great amount of
particles with so called \"children\", that mimic the behavior of their
parents. The amount of particle parents should be as low as possible,
but you need a certain amount to control the distribution of the hair.
We will also use as little control points as possible, three segments
should be enough for short fur.

-   Set the *Amount* to 1000.
-   Set the number of *Segments* to three. **New** I can\'t find this in
    2.69. **New2** In 2.7x, it\'s right next to the particle system type
    you just chose (emitter or hair), below the slider *Seed*.
-   *Emit from:* **New** I can\'t find this in 2.69. **New2** In 2.7x,
    you must check the *Advance* box near the *Segments* slider in order
    to see it.
    -   *Random*:*Faces*
    -   *Even* :*Random*

This will create a nice, uniform distribution.

Let the hair grow - the hair shows the path of the particle:

-   Set *Normal* to 0.05. **New:** Hair Length under Emission. **New2**
    In 2.7x, you must check the *Advance* box in order to see the
    *Velocity* panel and adjust the *Normal* and *Random* slider. If you
    change the *Normal* value, *Hair Length* will set itself to 0.2.
-   *Random* 0.005

Nothing special here: the hair grows in the direction of the face
normals. Length and direction are a bit randomized.

The *Visualization* type changes automatically to type *Path* if you
select a hair particle system. If you would render now, you couldn\'t
see the emitter object any more.

-   Activate *Emitter* in the *Visualization* panel. **New:** In the
    Render panel.
-   Activate *Strand Render*. **New:** In the Render panel.

The *Strand Render* (which I have baptized *keypoint strands* to
differentiate from the \"normal\" *polygon strands*) renders the hair
strands extremely efficiently and magnitudes faster than the normal
strand. It is the only way to handle many hairs in terms of memory
consumption. But it has a few disadvantages:

:   \- They are not seen by raytracing, so you don\'t get raytracing
    reflections and no raytracing shadows. You can use environment
    mapping to compute the reflections and *Spot Lamps* with buffer
    shadows for the shadow.
:   \- If the hair is very thick (like 1 BU) sometimes the shape is not
    correct.

-   Activate *Children from Faces*. **New:** I chose Interpolated under
    Children. Interpolated is known to give better results when making
    Fur. Simple, maybe, will work with one color, but we\'re going to
    use 2 colors from an image.
-   *Amount:* 5 This is the amount of children particles for each
    parent.
-   *Render Amount:* 50 This is the amount of particles during the
    render.
-   *Rough 2:* 0.1 **New:** I used *Roughness \> Random* for this
    setting. Random variation of the shape of the particles. So the
    hairs will not stand plain upright and appear a bit curly.

The parent particles are not rendered by default, so now we have 5.000
Particles that render on my old machine in 6 seconds. If we use 1.000
children we have 1.000.000 particles, that need approx. 1 GB of RAM and
render in 1:42 minutes. If you render *keypoint strands* with *Children
from Faces* you can also use *Child simplification*, which will reduce
the amount of particles on objects far away from the camera
automatically. **New:** Don\'t see this when using Children - Simple,
When using Children - Interpolated, you\'ll see it all down the Render
section. However, the result is very bad, with the standard settings.

!**Figure 2c:** The first render without
material.{width="300"}
Now we should change the lighting to get a preview.

-   Select the lamp.
-   Change to the *Lamp* buttons.
-   Change the lamp type to *Spot*.
-   Change the shadow type to *Buf. Shadow*
-   Change the buffered shadow type to *Classic-Halfway*.

This is a great shadow type that renders keypoint strands very well and
creates fewer artifacts than *Classical* (In my opinion). I have
inserted two other lamps and used a classical three point lighting for
the first rendering (**Fig. 2c**).

!200 px\|left\|Click on image to see larger
version.
**NEW:**  Here are the settings
I used and the render result I got. (Click to enlarge the image and read
the settings.)

## Material

In the material buttons you can set different aspects for the strands:

:   \- their width and form
:   \- the used shader
:   \- the base color
:   \- a texture along the strand
:   \- different particle attributes like length, density or roughness

-   Add a material to the emitter.
-   Name the material \"Fur\".

### Strands Shader

framed\|**Figure 3a:** *Strands* settings in the material
buttons. The
default strands settings for *Keypoint strands* are shown in
**Fig. 3a**. Take a look in the Manual about
Strands
for an explanation of all settings.

-   Change the *End* value to 0.25, this will make the hair more spiky
    (not shown in **Fig. 3a**). **New** In 2.7x, it\'s called *Tip* (and
    *Start* has become *Root*)

### Giving the hair its base color

!**Figure 3b:** Fur color
texture{width="200"}
Strands are rendered with the material of the underlying face/vertex,
including shading with an UV-Texture. Since you can assign more than one
material to each face, each particle system may have its own material
and the material of the underlying face can be different from the
material of the strands. We will use an UV texture and use it for the
surface of the emitter as well as for the color of the hair.

-   Change to *Front* view in the 3D window (*View-\>Front*).
-   Make sure you are in *Orthographic* view mode (also in the *View*
    menu).
-   Change to *Edit* mode of the sphere.
-   Press **U** to unwrap, select *Sphere from View*. This is a quick
    and well working method to correctly unwrap a sphere the easy way.

You don\'t need to assign a texture in the *UV/Image Editor*, we only
need the coordinates now.

!**Figure 3c:** Emitter with color
texture.{width="300"}

-   Add a texture to the material, name it \"FurColor\".
-   Set *Map Input* to *UV*.
-   Go to the *Texture Buttons* and set *Texture-Type: Image*.
-   Load an image texture. I have used the image in **Fig. 3b**.

Normally I would just stop here, I think the material is good enough.
But if you want to make the fur more fluffy and soft, you should a
second texture along the strand, which changes the alpha value. **New:**
For this to work you have to choose *Interpolated* instead of *Simple*
in the *Children* panel of the particle system.

!**Figure 3d:** Settings for a texture along the
strand.{width="400"}
If you want to do that:

-   Activate *ZTransp*.
-   Add a second texture.
-   *Map Input:* *Strand*
-   *Map To:* *Alpha* and *Spec*, *DVar*=0
-   Use a blend texture (*Linear* or *Quad*)

You can change all other properties this way, for example the color
along the strand (bleached tips).

## Changing Hair length with a texture

At first I will show you how to render the emitter mesh with a different
material than the strands. Then I will show how to change the length of
the hair with a texture semi-interactively.

-   Change to the *Editing* Buttons.
-   Change to *Edit* mode.
-   In the *Links and Materials* panel click on *New* in the material
    section (see **Figure 4a**).!**Figure 4a:** Button to
    click{width="300"}
-   Make sure all vertices are selected.
-   Click on *Assign*.
-   Change back to *Object* mode.

Now the emitter bears a second material.

-   Return to the material buttons.
-   In the *Links and Pipeline* panel click on the **X** next to the
    material name (*Deletes link to this Datablock*).
-   Add a new material.
-   Name it *Emitter*.

Now you have a new material on your emitter object. Since the particle
system uses material no. 1 you can use different settings for the
emitter.

!**Figure 4b:** Texture
painting{width="300"}
We have already unwrapped the emitter, this is something that will
probably be the case also for any real models. Now we will use an
UV-Image and texture painting to determine the hair length.

-   Split the 3D window.
-   Change the right hand side to an *UV/Image-Editor* window.
-   Change to edit mode of the emitter object.
-   In the *UV/Image-Editor* use *Image-\>New\...* and confirm the
    default settings. This will create a new image, that we will paint
    on.
-   Click on the package icon in the windows header of the
    *UV/Image-Editor* window. Confirm.
-   Change the object to *Texture Paint* mode. **Noob Note:** *In the 3D
    Window, click on the drop down menu. Change it to***Texture Paint**.

Now you see the texture on the object.

-   Paint a structure on the object.
-   Change back to object mode.
-   Go to the *Material* buttons.
-   Change the active material to *Fur* (click on the arrows in the
    *Links and Pipeline* buttons where it reads *2 Mat 2*).

framed\|**Figure 4c:** Material settings for setting the particle
length with a
texture.

-   Create another texture. Name it *FurLength*.
-   Set *Map Input* to *UV*.
-   Set *Map To*
    -   Turn *Col* off.
    -   *PAttr*
    -   *Length*
    -   *DVar=0* All the white areas on the texture will produce a
        particle length of 0.
-   Load the image texture that we have painted.

!**Figure 4d:** Controlling particles with a texture:
result{width="300"}
The result is shown in **Fig. 4d**, you can also see the particles
change in the 3D window.

**New** In Blender 2.7x, things have changed. I followed until the step
*Change the active material to Fur*. Then, I went to the *Texture* tab
and clicked on the *Particles Texture* button next to the *Material
Texture* button (or you can click on the *Particles* tab button !20
px and then click on the
*Texture* tab button). I added a new texture, opened the one I had just
painted in the *UV/Image-Editor*, set *Coordinates* to *UV* (in the
*Mapping* panel). Finally, I enabled *Density* in the *Influence* panel
and set its value to *-1.00* (*1.00* has the opposite effect = hair on
the white areas of the texture). The result should be the same as above.

There would have been other ways to achieve this result, e.g. with
vertex groups or with particle editing. But I like to work with
textures, because you have very fine control and may change the strength
of the effect at any time. Vertex groups don\'t allow for such fine
control or you need very many vertices in the emitter. Particle editing
(what we will do in the next step) is lost if you change the base
particle settings late on, and you can\'t change it\'s effect so easily.

## Comb it!

framed\|**Figure 5a:** Combing in *Particle
Mode*

An effect that is often underestimated is the importance to comb fur in
the natural directions. Fur doesn\'t simply stand upright, and it also
doesn\'t follow gravity (or only to a small amount). So back to the
particle system!

-   Change back to the *Particle buttons*.
-   Click on *Set Editable* in the *Particle System* panel.
-   Change to *Particle Mode*.

*Particle Mode* only appears if you have made the particle system
editable, and only hair systems can be made editable. There are a few
lifesavers to know when working in *Particle Mode*.

:   \- you can edit only the control points (remember the setting
    *Segments* from the beginning of this tutorial)
:   \- you can only edit parent particles, so you need enough parents
    for good control

-   Activate *Limit selection to visible*
-   Activate *Point select mode* for even finer control.

Both settings are in the window header of the 3D window.

-   Open the *Particle Edit Properties* panel with **N** key in the 3D
    window.
-   Select *Comb*.

You have quite a few different tools at hand in *Particle Mode*, see the
manual on Particle
Mode.

-   Comb the hair following the natural flow.

On the example sphere I have used here it is a bit difficult to tell
what the natural flow should be ;-). So I have just very carefully
combed and changed the length at a few places a bit. You find the
rendered result in **Fig. 1**, the Blend file is linked below.

## Links

-   A tutorial in German that shows how to create
    Grass
    with a very similar method.
-   Awesome fur shown here:
    Tiger


# Blender 3D: Noob to Pro/Fireworks

|previous=Furry
}}
```
framed\|**Figure 1:** Some particle
fireworks \[Note: In
newer versions of Blender, the reactor particles are gone.\]

\[if you use 2.6x version of blender, then you could watch the YouTube
video {particles from particles part1/2}. It\'s a great tutorial, but
the part 2 of it uses compositing, which is described in this book a
little later. Therefore, you could apply the knowledge you have learnt
from this book to animate the explosions!\]

How to create a firework from particles? We will use cascaded particle
systems especially of the type *Reactor*. Abstract:

-   We create a emitter object in the appropriate size.
-   Than we use three successive particle systems:
    -   the first of the type *Emitter*
    -   the second of the type *Reactor*. This system reacts to the
        death of the emitter particles.
    -   the third again of the type *Reactor*. This systems reacts to
        the proximity of the second systems and thus creates a \"drag\".
-   We create three different materials (one of them animated) and
    assign them to the three particle systems.

\
== The Emitter == We use a *Plane* as emitter object. Scale it to your
liking. I have used a relatively large particle system, so my plane has
a length of 15 BU (Blender units).

framed\|**Figure 2a:** Adding particle systems. First particle system
on the left hand side, a second particle system on the right hand
side

-   Add a particle system (**Fig 2a**, left hand side).
    -   *Amount:* 25
    -   *Sta:* 1
    -   *End:* 250
    -   *Emit from:*
        -   *Random*
        -   *Faces*
        -   *Even*
        -   *Random*
    -   *Initial Velocity*
        -   *Normal:* 22
        -   *Random:* 7
    -   *AccZ:* -9.8
    -   *Visualisation:* *Line*
        -   *Back:* 1.1

A few particles (25) are created in the first 250 frames of the
animation and emitted upwards. Gravitation, velocity and lifetime are
adjusted so, that the particles reach the end of their lifetime at the
topmost point of their trajectory.

The *Line* visualization lets the particles appear as long drawn-out
line.

-   *Bake* the particle system. Use 500 as the *End* frame for bake. 300
    would be sufficient here, but 500 do no harm.

Noob Note: Bake is in the Bake tab next to particle system tab in
particle buttons window.

The plane will get a *Halo* material.

-   Activate *Halo* in the *Links and Pipeline* panel.
-   *Halo:* color red
-   *Halo Size:* 0.421
-   *Hard:* 35

I\'ve adjusted the size and hardness of the halo so long until I liked
it, so there is no specific reason to use these values.

## Reactor 1

-   Click on the arrow next to *1 Part 1* in the *Particle System*
    panel.
-   The settings for the first particle system are no longer shown, now
    it reads *1 Part 2* (**Fig. 2a**, right hand side).
-   Click on *Add New*, now it reads *2 Part 2*.

You just have created a second particle system. Rename this system, a
good naming convention will help you a lot to keep the overview.

framed\|**Figure 3a:** The first reactor
system

-   Activate *React on: Death*.
-   *Life:* 104
-   *Emit from:* *Particles*

You don\'t have to set anything for the *Target*. It is not necessary to
set the target object if it is the same object as the reactor. You just
have to set the number of the target particle system eventually.

The *Reactor* particles react on the *Death* of the particles of the
target system. They will be emitted from the point that the particles
occupy at their death.

To control the movement of the system, I have made following setting in
the *Physics* panel:

-   *Particle:* 0.345
-   *Reactor:* 10
-   *AccZ:* -0.09
-   *Brown:* 3.86

Because of the *Reactor* setting the star is moving away from the
emitting particles. The *Brown* movement lets the trajectory appear
trembling like affected by wind.

-   Set the material number to \"2\" in the *Visualization* panel.
-   Bake the system, again use 500 as end frame.

### Material 2

framed\|**Figure 3b:** Material settings for the 1. *Reactor*
system

-   At first you have to assign a new material in the *Link and
    Materials* panel of the *Editing* Buttons.
-   Use the material settings from **Fig. 3b**,
-   The material also gets a *Clouds* texture with *Noise* depth \"3\",
    simply leave all other settings unchanged.

The texture is actually superfluous here, but the next particle system
is given the same texture, and colors should be adjusted a bit.

-   Animate the *Alpha* value of the material.
    -   Set the first Ipo key in frame 1 (*Alpha=1*). To do that move
        your mouse cursor over the *Buttons* window. Press
        **I**-\>*Alpha* (and change ipo type to material in the ipo
        curve editor if you are using that).
    -   Set the second Ipo key in frame 86 (*Alpha=0.75*).
    -   Set the third key in Frame frame 101 (*Alpha=0.0*).

The second particle system is faded off relatively quickly, but the
particles don\'t disappear suddenly.

\

## Smoke Trail

framed\|**Figure 4a:** Particle system for the
trail The third
(and last) particle system is again a *Reactor* system and is reacting
to the second system. It\'s going to react to the *Nearness* of the
particles. Without moving the variation of the particles is created with
a texture and a random variation of their lifespan. What Blender
considers as close can be changed with the particle *Size*.

-   Create a third particle system (like you created the second).
-   Use the settings from **Fig. 4a**. Important are the settings:
    -   *Amount:* 100000
    -   *React on:* *Near*
    -   *Emit from:* *Particles*
    -   *Life:* 75
    -   *Rand:* 0.4
    -   *Target Sys:* 2
    -   *Material:* 3
-   Bake the system, again use 500 as end frame.

\
=== Material 3 === framed\|**Figure 4b:** Material for the *Trail*
particle
system

-   At first you have to assign a new material (the third) to the object
    in the *Link and Materials* panel of the object buttons.
-   Assign the existing *Clouds* texture from material 2 also to
    material 3, but select a dark blue as target color (in the *Map To*
    panel).

\

## Render

-   Render your animation, use end frame 500.

That\'s all. I hope you were able to follow the tutorial. Criticism and
suggestions, write best on the talk page or improve the article
directly.


# Blender 3D: Noob to Pro/Particles forming Shapes

|previous=Fireworks
}}
```
```{=html}

```
```{=html}

```
```{=html}

```
!**Image 1a:** Particles can move to the position of other particles
with *Keyed*
physics.{width="400"}

```{=html}

```
```{=html}

```
!**Image 1b:** Particles can react to force fields of other
particles.{width="400"}

```{=html}

```
```{=html}

```
```{=html}

```
_Note all the blender users of version 2.6X,
2.7X_: Using sort of a domain to dissolve the particles by
using the alpha parameter of the material is how I did it. You should
understand along the way. I'll write the sentences in key sequences to
reduce the size. So \[s\], 0.5, \[enter\] means to scale the object by
0.5. Don't worry you'll learn keyed physics here.

-   Open a new blender file.
-   Delete the default cube.
-   \[shift\]+\[A\],text.
-   \[num0\]
-   In the menu, below the tool shelf check align to view.
-   Select the text object, \[alt\]+\[c\], convert to mesh.
-   \[shift\]+\[a\], add Suzanne.
-   \[ctrl\]+\[2\], not the numpad.
-   Set smooth.
-   In the modifier's tab apply the subsurf immediately.
-   If you want you can scale the objects.
-   Add a particle system to text object.\[I leave the renaming parts to
    you\]
-   In the emission subpanel of the text object's particle system:
    Number:5000; Start/end(both):1; Emit from: faces, check random and
    even distribution, random; Physics: none; Uncheck emitter in the
    render subpanel and choose none rather than halo.; Set all to zero
    in the field weight's sub panel(actually I didn't notice much
    difference it even being on).;
-   Now add a particle system to Suzanne and give it the same particle
    system but make sure to have it made to a single user(just press the
    '2' beside the system name).
-   \[shift\]+\[a\], uv sphere.
-   Selecting the sphere, \[alt\]+\g\.
-   \[s\],2000,\[enter\].
-   \[ctrl\]+\[2\],set smooth and apply the modifier.
-   Give the same particle system to the sphere.
-   Now \num0\.
-   \[LMB\] on the pass partout(the greyed out area except for the
    camera).
-   \[shift\]+\[a\], add cube.
-   Give the cube a particle system.
-   Assign the same particle system but let's make a few changes: In the
    physics subpanel select keyed.; In the render subpanel choose halo.;
    In the menu labeled keys, click the '+' icon thrice and set the
    target object to text , Suzanne and sphere in order.; Now select the
    Suzanne's particle system in the keys menu, check use timing and set
    it to 200. Now select the sphere's and set the time to 7025! ( well
    this is just to lower the speed we won't render this).; And set the
    life time of these particles to 500.(this is in the emission
    subpanel).;
-   In the timeline header set the end frame to 300.
-   Now for the material. Select the cube and: Give it a new material.;
    Select halo.; Size: 0.03; Hardness: 16; Add: 1; RGB: As you desire
    how the particles appear.(I did RGB=0, 0.106, 0.8); Now go to frame
    260 and insert a keyframe to alpha value.; Now go to frame 270 and
    insert make the alpha value zero and insert another keyframe.;
-   Set the scene's gravity off.
-   \[ctrl\]+\F12\

\

```{=html}

```
I will show on this page two ways to let particles take the shape of
other objects.

1.  keyed particle physics (**Img. 1a**)
2.  a harmonic force field with a damping of 1. The force field is
    emitted by another particle system, so that each particle is
    attracted by another particle (**Img. 1b**).

v2.48: The second method is easier to control, but I\'ve found that it may not work exact enough. Even if you use RK4 as calculation method, there are some glitches in the precision of the calculation, so that your particles may not come to a standstill (depending on the size of the particles and their number this may be visible or not).\
v2.49: That the particles didn\'t come to a standstill has been a bug that Jahka has fixed in 2.49. So if you use Version 2.49 and upwards you will find it easier to work with the harmonic force field.

## Keyed Physics

So here we\'re going to use keyed particle physics and quite a few
different particle systems.

Basically this is the way to go:

-   Use mesh objects and let them emit particles.
-   Each system moves to another system because of the keyed physics.
-   Choose a good visualization of the particles and animate that also.
-   At last the hard part: sync the different animations.

The animation shall last 300 frames, this will be 12 seconds.

:   \- In the first 2 seconds the word \"Blender\" shall appear (frame 1
    to 50).
:   \- Than Suzanne shall build up in 3 seconds (frame 51 to 150).
:   \- Suzanne shall be clearly visible for a few frames (frame 151 to
    200).
:   \- After that the form shall dissolve and the particles move a bit
    until they vanish (frame 200 to 300)

### Preparing the scene

-   Remove the cube.
-   Add a text object *Blender*. Name it *Blender-first*.
-   Add a *Suzanne* (*Add-\>Mesh-\>Monkey*). Name it *Suzanne-first*.
-   Convert the text object to a meshobject, because only mesh objects
    can emit particles (menu: *Object-\>Convert Object Type-\>Mesh*).
-   Move the objects to their final positions, also the camera.
-   **Clarification required - what are the final positions?** (**Noob
    note**: the author probably means to move the camera and objects to
    a right position for viewing the animation correctly.)

We need every visible object twice.

-   Duplicate *Blender-first* and call the duplicate *Blender-last*.
-   Duplicate *Suzanne-first* and call the duplicate *Suzanne-last*.

One problem is that the objects have different sizes. So how many
particles shall be used to create a clearly visible form? Since the most
difficult object is Suzanne, I have first chosen an acceptable
representation and set everything else accordingly. But I will discuss
the settings of the objects in order, and not in the way I did it in
reality.

### Set up the particle systems

**Blender-first:**

-   Add a particle system to *Blender-first*.
    -   Amount *20.000*
    -   *Sta:* 1, *End:* 50, *Life:* 50
-   *Emit from:*
    -   *Random/Faces/Even/Random*

Leave all other settings at default. This object will appear in the
first 50 frames. After that the object has to vanish in the 51st frame.

-   Insert a layer key for *Blender-first* in frame 50 (mouse over the
    3D window, **I**-\>*Layer*).
-   Change to frame 51.
-   Move the object to layer 20 (**M**-\>select layer, bottom right
    box). Make that layer visible.
-   Insert the next layer key for the object.
-   Make layer 20 invisible again (select layer 1).
-   Change back to frame 1.

**Suzanne-first**

-   Add a particle system.
    -   Amount *20.000*
    -   *Sta:* 50, *End:* 100, *Life:* 200 (we don\'t need this long
        life but the lifetime doesn\'t matter as long as it\'s long
        enough)
-   *Emit from:*
    -   *Random/Faces/Even/Random*
-   *Visualization: None*

Leave all other settings as default. These particles shall not move and
they shall not be visible. They are simply a target to the next system.

-   Animate the layer of this object also. Move it out of sight in frame
    151.

**Blender-last**

These particles shall move from the shape \"Blender\" to the \"Suzanne\"
shape.

-   Add a particle system to *Blender-last*.
    -   Amount *20.000*
    -   *Sta:* 51, *End:* 51, *Life:* 100
-   *Emit from:*
    -   *Random/Faces/Even/Random*
-   Physics:
    -   *First/Keyed* It is the first system of a chain (a very short
        chain in this example) of systems.
    -   *Keyed Target:* Suzanne-first, *Psys:* 1. Target is the first
        particle system of \"Suzanne-first\".
-   Set time to *Absolute* in the *Extras* panel. We\'re going to
    animate the material of the particles, I want all particles to
    change at once in a certain frame.

framed\|none\|**Image 2a:** Particle system of the first keyed
system.

**Suzanne-last**

These particles shall dissolve the form, so at first they take the shape
and move around randomly afterwards.

-   Add a particle system to *Suzanne-last*.
    -   Amount *20.000*
    -   *Sta:* 151, *End:* 151, *Life:* 150, *Rand:* 0.5. The lifetime
        is randomized from 151/2 to 151 frames. \[Noob Note: In 2.49a,
        you can\'t set the start later than the end, so you must first
        change the end to 151, then change the start.\]
-   *Emit from:*
    -   *Random/Faces/Even/Random*
-   *Bake:* *End* frame 300. Though we don\'t use baking here, you have
    to set the *End* frame in the *Bake* panel. Else the last 50 frames
    wouldn\'t be calculated.
-   *Time: Absolute*

framed\|**Image 2b:** Animation of Brownian
Motion
Animate the Brownian motion of the particles.

-   Open an *Ipo* window.
-   Select *Ipo Type* particles.
-   Select the *Brown* channel (**LMB**).
-   **Ctrl-Click** with the left mouse button in the *Ipo* window to
    create an Ipo-key for the selected channel.
-   Create a curve similar to **Img. 2b**. **Brown** = 0 to frame 200,
    than increase to **Brown** = 4 in frame 217.

### Material

Blender-first and Blender-last will get the same material, Suzanne-first
is invisible anyway, but Suzanne-last will get a material. The material
of the three objects is very similar, but I have animated the visibility
of the particles to match the brightness of the objects.

framed\|none\|**Image 2c:** Material settings for the
particles
**Suzanne-last**\
\* Create a simple *Halo* material like that in **Img. 2c**. This is
nothing special, relatively small particles with a relatively \"sharp\"
edge. The *Add* parameter gives more brightness if particles overlap, I
think this is a nice effect here.

**Blender-first**

-   Assign the material also to \"Blender-first\".
-   Make the material a *Single User Copy* by clicking on the small
    number next to the material name.
-   Set *Alpha* to 0.438.

**Blender-last**

-   Assign the \"Blender-first\" also to \'\'Blender-last\".
-   Make the material a *Single User Copy* by clicking on the small
    number next to the material name.
-   Animate the alpha value of the material.
    -   Insert an *Ipo* key for *Alpha* in frame 50.
    -   Change to frame 150.
    -   Set *Alpha* to 1.
    -   Insert an *Ipo* key for *Alpha*.

Now the brightness of all systems are matched.

### Links

-   Manual about Particle
    physics

## Harmonic Force Fields

So here we will use *Harmonic* force fields. The Text \"Blender\" shall
be transformed to the text \"2.5\" and than to the text \"The big leap
forward\" (**Img. 1b**).

-   Use mesh objects and let them emit particles. Only the particles
    from the first object are visible and move.
-   The other particle systems use an animated *Harmonic* force field to
    attract the particles from the first system.
-   The particles from the first system take the place of the other
    particles.
-   Choose a good visualization of the particles and animate that also.
    This is difficult and maybe you should animate the visualization at
    last.
-   At last the hard part: sync the different animations and force
    fields.

### Preparing the scene

-   Remove the cube.
-   Add three text objects:
    -   \"Blender\"
    -   \"2.5\"
    -   \"The big leap forward\"
-   Convert the text objects to mesh objects (menu: *Object-\>Convert
    Object Type-\>Mesh*).

### Set up the particle systems

-   Give each of the three objects its own particle system.
-   The first object \"Blender\" gets following system:
    -   Type *Emitter*
    -   *Amount*=4000. We need a lot of particles, to fill the last text
        evenly. If you want to make the animation even better, you could
        animate the *Halo* size of the particles to match the density of
        the different objects.
    -   *Sta(rt)*=1, *End*=10, *Life*=250. The particles are created
        from the first to the 10th frame and live for 250 frames.

Only the particles of this system will be visible later.

-   Change the calculation method from *Midpoint* to *RK4*. We need the
    extra precision here.

The objects \"2.5\" and \"The big leap forward\" will get particle
systems with very similar settings:

-   \"2.5\":
    -   Type *Emitter*
    -   *Amount*=4000
    -   *Sta(rt)*=30, *End*=30, *Life*=70. So all the particles are
        emitted in frame 30 and live 70 frames. So their force field
        (which we give them soon) will start in frame 30 also. If you
        want a smoother transition you should give the particles a bit
        more time to be emitted (like from frame 30 to frame 40).
    -   Emit from *Random*/*Faces*/*Even*/*Random*.
    -   Phyics *None*. The target particles shall not move.
    -   Visualisation *None*. The target particles are not rendered.
-   \"The big leap forward\": All settings as for \"2.5\", except *Sta*,
    *End* and *Life*.
    -   *Sta*=101, *End*=101, *Life*=90.

### The force fields

framed\|**Image 3a:** The object does not get a force
field.
The **particle systems** of the objects \"2.5\" and \"The big leap
forward\" will get a force field now. The objects **don\'t** get a force
field.

-   Select the object \"2.5\".
-   Select the particle system in the *Field* panel of the *Physics*
    buttons (**Img. 3a**).

framed\|**Image 3b:** The particle system gets the force
field.

-   Use field type *Harmonic*. Now the particles from the object \"2.5\"
    do attract the particles from the object \"Blender\".
-   The *Strength* of the force field determines the time the particles
    need to reach the target. Set it accordingly.
-   The *Damp*(ing) makes sure, that the particles move to their target
    but not beyond.

Do the same for the object \"The big leap \...\", i.e. select the
particle system and give it a *Harmonic* force field.

I have used a *Wind* field in the last frames to blow the particles
away.

(Noobie Warning: When i followed the tutorials up to this point, i
didn\'t know how to use wind. I thought selecting *Wind* instead of
*Harmonic* would create the effect but then blender froze on me (I am
guessing it went away and calculated wind for every single particle). so
don\'t try wind yet. Wind is instructed in later tutorials.)

### Links

-   The Blend file to
    download
-   The manual about force
    fields


# Blender 3D: Noob to Pro/Billboard Animation

|previous=Particles forming Shapes
}}
```
Billboard
visualization of particles - and especially their animation - is one of
the more arcane concepts in Blender. We\'re going to shed some light on
this. Billboard visualization is extremely powerful, everything that can
be done with a halo can also be done with a billboard. But billboards
are real objects, they are seen by raytracing, they appear behind
transparent objects, they may have an arbitrary form and receive light
and shadows. They are a bit more difficult to set up and take more
render time and resources.

*Billboards* are aligned square planes. If you move an aligned billboard
in a circle around an object, the billboards always faces the center of
the object. The size of the billboard is set with the Size of the
particle.

Texturing billboards is done by using uv coordinates that are generated
automatically for them.

-   The main thing to understand is that if the object doesn\'t have any
    UV Layers, you need to create at least one in the objects Editing
    buttons for any of these to work (**Img. 1a**).
-   Moreover, material should be set to UV coordinates in the Map Input
    panel (**Img. 1b**).

```{=html}

```
```{=html}

```
```{=html}

```
framed\|**Image 1a:** UV coordinates for Billboard
textures

```{=html}

```
```{=html}

```
framed\|**Image 1b:** UV coordinates as *Map
Input*

```{=html}

```
```{=html}

```
```{=html}

```
## Splitting a texture

framed\|**Image 2a:** Billboard settings and texture for UV
split
The simplest thing we can do is to give every billboard its own fraction
of an image texture. We\'re going to use a simple image (**Img. 2a**,
right hand side) and split this in four parts (*UV Split* = 2,
horizontally and vertically).

-   Create the UV coordinates (simply click on *New* next to *UV
    Texture* in the *Mesh* panel).
-   Create a particle system.
-   Activate *Billboard* visualization.
-   Set *UV Split* to 2.
-   *Offset: Random* to randomly choose one of the images sections. None
    would give only the first of the four fields, so all billboards
    would be red, linear would first use red, then blue, then white and
    then yellow repeatedly.
-   Set *UV Channel* to *Split*. This creates the necessary UV
    coordinates, that are stored in the UV layer. If you use another UV
    channel, you need a second (or third) UV layer to store the
    coordinates (see below for an example).
-   Fill in the field *UV* with the name of the coordinate set (here
    \"UVTex\").

!**Image 2b:** UV Split for
Billboards{width="400"}

-   Now create a material for the particle emitter.
-   Add a texture if not there already.
-   Set *Map Input* to *UV*. If you only have one active *UV* layer this
    is used by default, but if you want to continue this tutorial you
    have to fill in the name of the UV set also (i.e. \"UVTex\").
-   Load the texture as Image texture.

Now every billboard gets a random section of the texture (see
**Img. 2b**).

## Animating Alpha in relative particle time

framed\|**Image 3a:** Using an UV layer for time
animation
Now we\'re going to combine the texture split effect with an animation
of the billboard alpha. This is done in relative particle
time,
i.e. in the lifetime of each particle.

Billboard time is setup completely different than particle time.

-   Create a new UV layer (the second one). Name it \"UVTex.Blend\".
    Naming is not important here as long as it is unique.
-   Select the UV channel *Time-Index (X-Y)* in the *Visualization*
    panel of the particle system. Fill in the name of the newly created
    UV layer \"UVTex.Blend\". This creates an additional set of UV
    coordinates in this UV layer.

Now both UV layers with different UV coordinates will be used. The
material settings:

-   Activate *RayTransp* and *TraShadow*.
-   Add a second texture to your material.
-   *Map Input* also *UV*, but now use the UV layer \"UVTex.Blend\".
-   *Map To:*
    -   *Invert Alpha* and *Invert Spec*
    -   *No RGB* (since we\'re going to use a colorband texture)
    -   *DVar* = 0 to set Alpha to zero where the colorband is black.

This is one of the possible combinations for using a texture to make a
material transparent (**Img. 3b**), there are several other methods that
work as well.

framed\|none\|**Image 3b:** Material for the *Alpha* animation. This is
already the finished preview with the
texture.

**The texture is really the most important thing here.**

-   Use a linear *Blend* texture.
-   Activate *Colorband* for full control.

-   Adjust the colorband to your liking.

I\'ve mapped the texture so, that \"white\" means full opacity, black
full transparency. framed\|none\|**Image 3c:** Texture to control the
animation
time.

See this animation for the result of the
combined textures.

## Animating billboard color

!**Image 4a:** Animating Billboard color.
Animation{width="150"}
I will show here a second example for animating with a billboard
texture, because this is so important. We\'re going to change the color
during the lifetime of the billboard, but you can animate every property
that way that can be influenced by a texture. Additionally you can
animate the material itself, this is done in absolute time for
billboards. So you can mix relative and absolute time animations.

-   Open a new file.
-   Remove the cube and add a plane.
-   Add an UV layer to the plane
-   Add a particle system with *Billboard* visualization and *UV
    Channel* Time-Index. Fill in the name of the UV layer.

The particle life time is 50 frames.

-   Add a material to your plane.
    -   Basis color *Yellow*.
-   Use a linear blend texture. If you would use a color band here, you
    could create an even more colorful animation.
    -   *Map Input* UV
    -   Fill in the name of the UV layer.
    -   *Map To* *Col*. I\'ve used a dark blue color here.

Now the linear blend texture sets the amount of blue color that is mixed
to the basis color of the material.

-   At the left hand side the blend texture has a value of 0, so zero
    blue is mixed to the base color in the first frame of the particle
    lifetime.
-   At the right hand side the blend texture has a value of 1, so 100%
    blue is mixed to the base color in the last frame of the particle
    lifetime.

## Changing the starting color of a billboard

framed\|**Image 4b:** Flipped XY for the blend
texture
If you flip the Blend texture, you get a different effect. Now every
Billboard gets another starting color, but keeps that color during it\'s
lifetime.

Have I mentioned that you may use multiple textures on a billboard,
combining all effects?


# Blender 3D: Noob to Pro/Soft Body Animation

|previous=Billboard Animation
}}
```
Due to rapid updates in Blender, some menu items may be different from
those mentioned here. If the menus don\'t agree then just do what seems
logical.

Softbody makes each individual vertex its own object that falls
according to gravity and reacts to outside forces like fields. By
adjusting the settings, you change the behaviour of the edges that
connect the vertices. For example, you can make it so edges can stretch
really far (aka elasticity), allowing the vertices to become distant, or
you can make the edge stiff, so the vertices will always stay the same
distance apart.

To put this in perspective, picture two cloths, one elastic and one
cotton. The elastic one has edges that can extend, so if you view them
in wire-frame (with vertices and edges visible) you would see the edges
are more extended than an equal distance. The cotton one would only
stretch a little bit, so the vertices would stay essentially the same
distance apart.

We are going to make a big rubber ball, but not a big bouncy one, a flat
(and somewhat lifeless) one. Start with a sphere. I would use a cube
sphere or an icosphere, UV spheres don\'t deform well as they have too
few vertices. A cube sphere is made by subdividing a cube and doing a
\"To Sphere\" in the Edit window, under Mesh Tools.

Move the sphere up and place a plane below it. Make sure to do this in
the right views so that it is aligned properly. Gravity acts on the
z-axis (sphere should be above the plane relative to the z axis).
![](tut.sb.1.jpg "tut.sb.1.jpg"){width="500"}{{-}} Now for the soft body
select the ball and go to the object tab then the physics subtab or
whatever your version has. Click \"enable softbody\" and then turn up
\'Grav\' to 9.8. Click off use goal. Press the \> arrow key (a few
times) and you should see the ball fall. The center will remain in place
but this is not a problem. If you are on a slow machine you will notice
lag. This is because blender moves it vert by vert, not efficient.

**Note: in Blender 2.49, you must deselect the \"Use Goal\" button to
release the center of the ball. Otherwise, it will just hang there.**

Note: In Blender 2.44, click F7 on keyboard, select the \"Physics
Buttons\" button, select \"Soft Body\".

![](tut.sb.2.jpg "tut.sb.2.jpg"){width="500"}{{-}} When it reaches the
plane it will pass through. To fix this we must make the plane affect
the softbody. To do this make the plane deflect in its physics buttons.

**Noob Note:** *To do this in version 2.49 select the plane, go
to*object buttons -\> physics context -\> collision subcontext\'\' and
select ***Collision**.*The variables you can play with here are under
the \'**\'Soft Body and Cloth Interaction**.

![](tut.sb.3.jpg "tut.sb.3.jpg"){width="500"}{{-}} Now the ball
collapses into a strange quivering wreck after impact. To fix this, you
need to turn on the stiff quad button, but set the edge stiffness down a
bit, so its more bouncy. You can use the bake function to solidify the
settings see below

Noob Note: `<i>`{=html}You might have to turn up the
`<b>`{=html}Rigidity`</b>`{=html} Level to 0.100 (in the Soft Body Tab)
as well in order to prevent the object from collapsing. (I used a
subdivided cube as Object)\
What I recommend to do before rendering as animation: In the
`<b>`{=html}Bake Settings`</b>`{=html} (Soft Body Tab) Set
`<b>`{=html}Interval`</b>`{=html} to 2 or 1, so the object will not
start deforming too early before impact. This will slow down the bake
process - just slightly - but make the object bounce more dynamically.
Then bake again. `</i>`{=html}

`<i>`{=html} Noob note: In blender 2.46 you have to adjust the value of
Be in the soft body tab, I changed it to 0.4 `</i>`{=html}

![](tut.sb.4.jpg "tut.sb.4.jpg"){width="500"}{{-}}

## Explanation of Settings

I invite you to correct and expand these definitions:

### Softbody

-   **Friction**: creates a resistance to movement of the whole object,
    like being submerged in a viscous fluid
-   **Grav**: the rate of velocity change due to gravity. Results in a
    constant -z force.
-   **Mass**: (Force = mass × acceleration) affects everything by making
    the object heavier.
-   **Speed**: tweaks the simulation to *run* faster or slower.
-   **ErrorLimit**: raise it and the simulation will solve faster but
    strange things might happen. Save frequently, as blender might go
    nuts with this or any physic simulation (but less so after 2.4)
-   **Goal**: makes the object try to return to its original position,
    useful at times, in the tutorial you could turn gravity off and key
    the ball falling and use this to keep it a ball.
-   **use Edges**: uses the edges a means of resistance to movement for
    the object. Helps to keep it looking possible


# Blender 3D: Noob to Pro/Simple Cloth Animation

|previous=Soft Body Animation
}}
```
In this tutorial, we will be making a simple skirt, and using the cloth
physics system to make it fall in realistic-looking folds.

## Making the Skirt Mesh

1.  Open Blender and delete the default cube, if you aren\'t looking
    down on the scene, press .

2.      → *Add → Mesh → Circle*

3.  The circle will be created, and in the Tool Shelf on the left you
    should see a panel appear for adjusting its settings. Set the number
    of vertices to about 12.

4.  Switch to Edit Mode with . All the
    circle's vertices should be initially selected; if not, use
     to select them all.

5.  Press  to extrude a second copy of the
    vertices; press
     to scale the extruded vertices
    in the X and Y directions. These will make up the hem of the skirt;
    scale it out to as large as you like. Note that this is positioning
    the skirt out flat horizontally, instead of hanging down as you
    would expect; Blender's cloth animation system will take care of
    that, and this positioning gives maximum opportunity for the skirt
    to fall in dramatic folds.

6.  Now we will need to subdivide the mesh. The physics can only act on
    actual vertices, so the more of these we have, the more realistic
    the cloth effect will be. Select all vertices in the skirt, press
     and select the "Subdivide" option. A
    panel will appear in the Tool Shelf for controlling the settings for
    the subdivision operation; set the number of cuts to, say, 4.

7.  While you're at it, switch to OBJECT mode and look in the Tool Shelf
    for a pair of "Shading" buttons titled "Smooth" and "Flat"
    ![](Blender263ShadingButtons.png "Blender263ShadingButtons.png"),
    and click on "Smooth".

## Creating the Vertex Group

1.  Now we have to specify that the waist of the skirt will stay fixed
    in place as it falls: deselect all vertices, and select the
    innermost ring of vertices. The quickest way to do this is to hold
    down  and click with
     on one of the edges bordering the
    hole in the middle. With the entire ring of vertices selected, go to
    the Mesh Object Data context
    ![](Blender_2.78_Mesh_Object_Data_Button.png "Blender_2.78_Mesh_Object_Data_Button.png")
    in the Properties window, find the "Vertex Groups" panel, and click
    the **+** sign to create a new group. This will initially be called
    "Group"; perhaps give it a more meaningful name (like "Waist"), and
    click "Assign" to put the selected vertices into the new group.

## Animating the Skirt

1.  Tab out of Edit Mode into Object Mode. The skirt should still be
    selected.
2.  Go to the Physics tab
    ![](Blender255PhysicsContextButton.png "Blender255PhysicsContextButton.png")
    in the Properties window (last icon in the row at the top). This
    will just show a few buttons to begin with
    ![](Blender263InitialPhysicsTab.png "Blender263InitialPhysicsTab.png").
3.  Click the "Cloth" button; a whole lot of other settings should
    appear, most of which can be left at their default values (make sure
    the checkbox at the top of the "Cloth Collision" panel is checked).
    However, check the box titled "Pinning"; now you can click in the
    field just below it to bring up a popup menu of all the vertex
    groups in the mesh; this should just contain the one entry named
    "Waist" you created earlier, so select that.
4.  Now the magic happens \... rotate the view to an oblique one to give
    yourself a good view of the process, and hit
    . You should now see the skirt
    fall from its horizontal position to a more natural vertical one,
    developing some folds in the process.
5.  After the animation has run through at least one complete cycle, hit
     to stop it.

## Prior to Keeping the Folds

Before doing the next step, we need to enable one of the standard addons
that come with Blender. This will let us make a copy of any stage of the
physics simulation into a separate object.

Go into the User Preferences window and bring up the "Addons" tab. Look
for the "Animation Corrective shape keys" addon (typing "shape k" into
the search box should be enough to find it).

Enable it. Now back to the 3D view\...

## Keeping the Folds

1.  Use the left- and right- arrow keys to step through the animation
    one frame at a time, until you find a position for the skirt that
    you like.
2.  When the 3D view is showing a nice shape for the skirt, go to the
    mesh data tab in the Properties window, and look for the "Shape
    Keys" panel. Click with **LMB** on the down-arrow just below the
    **+** and **-** signs, and in the menu that appears, you should see
    the item "Create duplicate for editing"
    ![](Blender263SaveAsShapeKey.png "Blender263SaveAsShapeKey.png").
    Select that.
3.  It looks like nothing has happened, but in fact you now have a
    second copy of the skirt mesh, "baked" into the position
    corresponding to the current frame of the animation. Try using the
    arrow keys to move through the animation, and you will see the baked
    copy remain in the chosen position.
4.  At this point, you can delete the original animated skirt mesh (or
    move it to another layer for future reuse), leaving the
    nicely-folded copy.

![](BlenderSimpleSkirt.png "BlenderSimpleSkirt.png")

## Extra Practice

1.  You will notice at some points during the animation, the folds of
    cloth pass right *through* each other, which is of course impossible
    with real cloth. To prevent this, you could go to the "Cloth
    Collision" panel in the Physics tab, and click the "Self Collision"
    checkbox. Rerun the animation ()
    to see the difference; what other effects does it have?
2.  Maybe the folds don't look realistic enough. Go back to the original
    mesh, bring up "Subdivide" again and subdivide it by a couple more
    levels. Rerun the animation (). It
    should take a bit longer for the first cycle, but do the results
    look better?
3.  This YouTube tutorial might also help:
    <http://au.youtube.com/watch?v=mgYhZ3hWwTQ> happy animating!


# Blender 3D: Noob to Pro/Soft Body with wind

|previous=Simple Cloth Animation
}}
```
## Prologue

This is the **Blender wind and soft body tutorial**. This tutorial will
try and help your knowledge of using Soft Body and the Fields and
Deflection panels in Blender 3D. (For best results, I recommend you use
Blender version 2.43 or higher). Don't forget to save your work at
various points throughout the tutorial.

## Setting up scene

### The plane

Delete the default cube \[X key, or yes, even the Delete key\] and enter
Front view mode \[Num. Pad 1\]. Add a plane, scale 3 times \[S key, 3,
Enter\] and sub-divide 4 times until you get something like the shape
below. If your computer can handle more, and you want more, sub-divide
as many times as you like, but if your PC is struggling with this, undo
once or twice.

![](Soft+wind.JPG "Soft+wind.JPG"){width="700"}

### The wind items

TAB out of edit mode (if you haven't done so already), enter side view
\[Num Pad 3\] and add an empty. Clear the rotation \[ALT + R\] and
rotate it 90° \[R, 90\]. Place it about -5 from the centre \[G, y, -5\]
and make sure its still in the middle of the X axis. Your scene should
look like the picture below:

![](Soft+wind2.JPG "Soft+wind2.JPG"){width="700"}

For the second wind item, add an empty like before and clear its
rotation, but DON'T rotate it any more. Move it along the Y axis by 4
places \[G, Y, 4\] and -10 by the Z \[G, Z, -10\]. And now your scene
should look something like this (with all items selected).

![](Soft+wind3.JPG "Soft+wind3.JPG"){width="700"}

And that's all your items you'll need for this. Onto the harder part.

## Designating each object\'s job

### The plane

Now, the plane will become a soft body, so enter the Object Panel
\[F7\], click on the Physics Button (beside the three arrows, see second
picture below) and click on the soft body button. You will get a load of
boxes, but we only need to look at the Grav, Goal, and the bottom parts:

![](Soft+wind4.JPG "Soft+wind4.JPG")

Change the values of these as shown above. Change the Aero part to 732
(if you go up to 1000, it changes the final output by a bit).

Now, click on the Soft Body Collision tab and click on the Self
Collision and Deflection buttons. You don't need to change any of the
numbers here. The buttons window should look something like this:

![](Soft+wind15.JPG "Soft+wind15.JPG")

Now we will move on to the Empty items which will be the wind.

### Creating the wind

The two empty's we created earlier will be the items that will act like
wind, and when you render at the end, they will be invisible, just like
the wind. Anyway, select one of the empty's and enter the Physics panel.
Click on the box under the Fields and select "Wind". (Blender 2.5+ note:
First you will have to choose \"Force Field\", then change the Type to
\"Wind\".) Change the Strength to 20, click on Use MaxDist and change
MaxDist to 2.5.

![](Soft+wind16.JPG "Soft+wind16.JPG")

Do the same for the other empty. Your scene should look something like
this:

![](Soft+wind5.JPG "Soft+wind5.JPG"){width="700"}

## The movement

This is probably the most complicated part, but shouldn't take long.

### The Empty on the left

In side view \[Num pad 3\], select the empty on the left and do the
following: 1. Press \[I key\] and then select LocRotScale from the list
it gives you. This inserts a key frame, saying that on this frame, keep
the Location, Rotation and scale the same throughout the rest of the
movie, unless it comes across another key frame, which might tell it to
move or stay the same. Now, press the Up Arrow Key until you get to
frame 31 (about 3 times). If you don't know where the box is that tells
you what frame your on, check the following picture:

![](Soft+wind6.JPG "Soft+wind6.JPG"){width="700"}

Number 1 shows the current frame number and the name of the selected
object while number 2 shows the current frame and allows you to change
the frame with the arrows on either side.

### Back to the movement

On frame 31, select the empty on the left (the one selected in the
picture above) and press \[G key\]. Now press \[Y key\] and press "4",
then \[Enter key\]. Now press \[I key\] and select LocRotScale again.
Now, if you press and hold the Left Arrow Key, you should see the Empty
move back to its starting place. Now, to check the curve guide (called
the \"IPO Curve Editor\"); right-click on the top panel (number 1 in
picture below), then select \"Split Area\" and click when the line is a
bit out from the side (number 2 in picture below).

![](Soft+wind7.JPG "Soft+wind7.JPG"){width="700"}

Now, click on the box (shown below) and select \"IPO Curve Editor\" from
the menu.

**Noob note** In Blender 2.6+ the **IPO Curve Editor** has been replaced
by the **Graph Editor**, which allows you to edit F-curves.

![](Soft+wind8.JPG "Soft+wind8.JPG"){width="700"}

This window just shows where the key frames you entered are, and how
much the shape changes, moves or rotates. Now, go back to frame 1 and
press \[ALT\]+\[A\], which plays the animation. You should see the
\"wind\" hit the sheet and the sheet will blow away. Pretty nice, huh?
Now, it would be fine like that (I'll show you how to get rid of the
blockyness in the last part), but say you want to hit the sheet again
and send it upwards? We will use the second empty for this.

Select the second empty (the one on the bottom). Insert a key frame (\[I
key\], LocRotScale) on frame 1 and frame 50. Go to frame 60, grab the
empty and move it up 8 places (\[G key\], \[Z key\], 8). Insert a key
frame (\[I key\], LocRotScale) and then go back to frame 1. You have
completed the basics, and the most of this tutorial. Now, press
\[ALT\]+\[A key\] and watch your animation.

## Finishing touches

### Blockiness

Now, to sort out the blockiness, go to the Editing buttons panel \[F9\]
and select the \"Set Smooth\" button.

![](Soft+wind9.JPG "Soft+wind9.JPG")

Now if you preview again (\[ALT\]+\[A\]) you should see the plane is
smoother, but might be a bit unrealistic (i.e. not acting like real
cloth). Now, that can't be helped, the only way to get rid of it is to
subdivide the plane several more times, but that will put a LOT of
strain on your computer, so I wouldn't recommend doing it unless your
computer can handle it.

### Background

First of all, got to the Scene panel \[F10\] and over at the Format
panel, change SizeX to 400 and SizeY to 300. Now, to change the
background colour when you render, go to the shading panel \[F5\] and
select the World buttons. Now, in the World panel change HoR to 0, HoG
to 0.80 and HoB to 1.0.

![](Soft+wind10.JPG "Soft+wind10.JPG")

All that does is just changes the background colour to a brighter, nicer
shade of blue. Now, I'm just getting a bit lazy, so I'll just explain
this part with a picture: (don't forget to select the plane).

![](Soft+wind11.JPG "Soft+wind11.JPG")

Change the values and press the buttons shown in the picture. This will
change the colour of the plane to white.

The only problem now is the light. Press \[F12\] and you should see what
I mean. There\'s no light shining on the plane where the camera is, so
its just shaded dark. To fix that, select the light and go to the
shading panel \[F5\]. You now have options for the light. Click on the
\"Sun\" button and press \[ALT\]+\[R\] to clear rotation. Now, in side
view \[Num pad 3\] press \[R\] and then type -45. Enter top view \[Num
pad 7\] and press \[R\] and then -45. This now shines the light in the
direction of the plane, but, if like mine, the light is above the plane
in top-view, press \[G\], \[Y\] and then -5. The line coming out of the
light source should be roughly pointing at the centre of the plane.
Here's what your window should look like:

![](Soft+wind12.JPG "Soft+wind12.JPG"){width="700"}

The pink line is the light. This was taken in camera view \[Num pad 0\].
Render the frame and you should see what the final product looks like.
Move to any frame you want and press \[F12\] and it will show the
rendered image for that frame. Now, rendering the entire animation
might, in fact, will take a long time unless you have a completely new
PC, are using a big server like DreamWorks (one of the big PC's, used
for rendering images faster) or have a quicker renderer, I don't use any
external renderers, and am stuck using a PC that is about 2 years old
(in other words, full of junk). It took my PC less than 5 minutes to
render 100 frames, and the last 25 were just blank (as the plane just
flew above the camera). To change the amount of frames to render, and to
render the full animation, here's what you press:

![](Soft+wind13.JPG "Soft+wind13.JPG")

The box that says End:100 lets you select what frame you finish
rendering the animation on (NOTE: the Sta:1 button lets you select what
frame to start rendering the animation). When you press the ANIM button,
it starts rendering the animation. The Box covered in blue, that says
Jpeg, lets you change the format of the image in the end.

To export the animation as an AVI format, select the AVI button shown
below, then press OK. Now, you need to Animate the sequence again, so
press the ANIM button again.

![](Soft+wind14.JPG "Soft+wind14.JPG")

The finished.AVI will be saved in a folder with the rest of your
rendered images. It should be saved in a folder called tmp, which (on a
Microsoft computer) is in My Computer/tmp. The name of the file will be
whatever your start and end frames are, so in this movie, mine is called
0001_0100.avi. You can now do whatever you want with your movie now, and
hopefully you have learned a trick or two that will be helpful later on
in your Blender career.

## Final result

Here is an animated.gif of my final result: (imported into Macromedia
Flash and exported as an animated.gif)You are required to be an auto
confirmed user or uploader. I made a gif with a frame-step of 4.
![](Soft_body_wind_blender_2.76.gif "Soft_body_wind_blender_2.76.gif")