# Blender 3D: Noob to Pro/Landscape Modeling I: Basic Terrain

|previous=How to Do Procedural Landscape Modeling
}}
```
## Introduction

I worked with a group to make a small animation for class and I was
responsible for the environment modeling. I really liked the results of
the process I used, so I decided to share it with others. By the end of
this tutorial you\'ll have the know-how to create your own flexible,
realistic terrain utilizing multiple textures for different ground
types. This tutorial assumes that you have the very basic understanding
of using Blender (how to add/remove a mesh, how to change views,
etc\...) I use the following textures in this demo. Feel free to use
them if you don\'t have something on hand to use.

![](Blender3DNoobToPro-Grass.jpg "Blender3DNoobToPro-Grass.jpg"){width="100"}

**NOTE:** This page uses a different grass texture for licensing reasons
(sorry).

## Creating the Canvas

!The grid that will be used to build our
landscape.{width="200"}
The \"canvas\" that we\'ll use for our terrain is an evenly spaced grid
of vertices. Open a new project, delete the default cube, and **add a
grid mesh**. Use whatever size you want. The more vertices you have, the
more detailed and realistic your landscape will appear, but don\'t get
crazy with it since we\'ll apply subsurfacing at the end to smooth it
out. At the same time, you do want enough vertices to prevent sharp
edges, and we\'ll need them in the second tutorial when we cover texture
stenciling. So consider how big you want your landscape and try to find
a reasonable balance. I like to start with 100x100. The grid will be
pretty small, so scale the entire thing up, let\'s say by a factor of
20. This grid will be used to build our landscape by pulling hills and
mountains out of it.

**Noob Note:** If you don\'t want to have to delete the default cube
every time you open a new file, just delete the cube once so you have
the blank window (only lamp and camera left) . Then select *File* -
*Save default settings* or hit *Ctrl+U*. From now on, each new project
you create will start off without the cube.

## Molding the Mountains

The key to making good mountains is using the proportional edit mode
(**OKEY**) and constantly adjusting the radius of influence. If you\'ve
already gone through the Mountains Out Of
Molehills
tutorial then this section will be familiar. One major difference is
that in this tutorial I recommend rotating the 3D view around so you
have a good view of all three axes instead of working in the front or
sides view. Using the proportional editing tool affects multiple
vertices, and it helps to see what effect your changes are having as you
make them.

-   Go ahead and turn on proportional editing, either by pressing
    **OKEY** or clicking on the grey ring on the 3D View header. You
    have to be in Edit Mode to select this option. Once proportional
    editing is enabled, the ring will appear orange and a new drop-down
    menu will appear next to it with different falloff styles. Select
    Smooth if it is not already selected.

![](Blender3DNoobToPro-Molding_the_Mountains_01.jpg "Blender3DNoobToPro-Molding_the_Mountains_01.jpg")

-   Select any random vertex and grab it (**GKEY**). You will see a ring
    around the vertex you are grabbing. This is the radius of influence,
    and only vertices inside this ring are affected by the
    transformation. If you are doing this in the orthographic view from
    the front, side, or top, then this will be obvious. But if you\'re
    at a view where you can see all three axes, then it may be less
    obvious.

!The first mountain created using proportional
editing.{width="200"}

-   Restrict movement to the z-axis (**ZKEY**) and translate the vertex
    upward. Throughout this entire process you ONLY want to translate
    along the z-axis. If you start moving vertices in the x or y
    directions, things become distorted and you get some nasty creases.
    Play around with adjusting the size of the radius of influence
    (**Mouse Wheel**) to get steeper or flatter hills.

!A nice group of
hills{width="200"}

-   Keep repeating this process with different size radii and different
    heights until you have a decent mountain range, but leave an area
    flat. We\'ll be using that spot later in the second tutorial. Don\'t
    be afraid to occasionally translate some vertices down instead of up
    to create depressions in the hills. Remember, variety is the spice
    of life. Very few things in nature are naturally geometric, so mix
    up your hills and especially make sure they overlap. How often do
    you see a nice, smooth hill all by itself in nature?

**Note:** You\'ll notice in my screenshot that I have reduced the size
of my grid. For simplicity\'s sake, I didn\'t feel like filling an
entire 100x100 grid with mountains since this can take some time.

-   Well now, that\'s looking pretty good! Now, there\'s one problem
    with our hills so far. They\'re too smooth! Let\'s bumpify them a
    little. Change the falloff type from Smooth to Random.

![](Blender3DNoobToPro-Molding_the_Mountains_04.jpg "Blender3DNoobToPro-Molding_the_Mountains_04.jpg")
!Rougher hills look more
realistic{width="200"}

-   Select a single vertex and grab it (**GKEY**). We\'re still working
    on the z-axis only, to restrict your movement with the **ZKEY**. Now
    when you move the vertex up and down, all vertices in the radius of
    influence will also move but with a random falloff instead of
    smoothly. It only takes a little movement to get the effect we want,
    so something around 0.5-1.0 is enough. Mix up moving up and down
    with different vertices, again to add variety to the scene.
-   Once you have your landscape the way you like it, add a subsurf
    modifier under the Editing tab (**F9**) and select Catmull-Clark.
    This will smooth out your terrain a little so that it\'s not too
    rough. Given the number of vertices you already have, it\'s not
    necessary to have a higher render value than 1 unless you just
    REALLY want it to be smooth, but I don\'t recommend it. Land is
    supposed to be bumpy and rocky, we just don\'t want sharp edges.

**Noob note:** If you\'re making mountains using Random Falloff and the
peaks stick up too much: in Edit mode, select the points in the area
around the peak using circle select, then press **WKEY** and click
\'Smooth\' until you\'re satisfied (or, in the Editing tab (**F9**),
click the \'Smooth\' button).

**Useful Tip** Proportional editing can be used on multiple vertices
simultaneously. This is especially useful if you\'re trying to create a
cliff face or a river bed. Use the box tool (**BKEY**) to select a group
of vertices and then translate them. Keep in mind that the size of the
radius of influence determines how many vertices around **EACH VERTEX**
will be influenced. So suppose you have a 5 vertex radius, that means
that 5 vertices all the way around your selected region will be
influenced.

## Texturing the Terrain

Alright! We\'ve got some pretty nice hills now! But there\'s still a few
problems. Hills shouldn\'t be white, and hills shouldn\'t be SHINY!
Let\'s dress them up a little, shall we?

-   With your landscape selected, go to the Shading Panel (**F5**) and
    add a new material.
-   Under the Shaders tab, drop the Specular value to 0.
-   Go to the Texture tab (**F6**) and add a new texture.
-   In the Texture Type drop down menu, select Image.
-   Two new tabs will appear. In the Image tab, click Load and load a
    texture from file.
-   In the Map Image tab, increase the Xrepeat and Yrepeat. Depending on
    the size of your terrain and the image that you use (please use
    something that tiles!), these values will vary. I\'ve used 10 for
    each in this tutorial.

![](Blender3DNoobToPro-Texturing_the_Terrain_02.jpg "Blender3DNoobToPro-Texturing_the_Terrain_02.jpg")

(**Noob note:** Render the scene (F12) to see the applied texture)
(**Noob note:** A quicker way to do this is by using the render preview
tool, 3d view window - render preview, View\--\> Render Preview or press
**SHIFT**\--\> **PKEY**) (**Noob note:** you may also select shaded in
the Viewport Shading menu next to where you select object mode or edit
mode to see your texture on your mountains without rendering, however it
does slow your computer down some which could make editing frustrating.
So only do this if you want to see what your textures look like, then
switch back to solid for more editing.)

-   Finally, let\'s do something about the lighting. Go to Object Mode
    (**TAB**) if you\'re not already there and select the lamp. Choose
    the Shading Panel (**F5**) and then click the icon that looks like a
    light bulb to display the Lamp buttons. Change the lamp to a sun and
    up the energy to 1.5. You may also need to increase the distance if
    your terrain is large, or rotate it around if you don\'t like where
    it\'s pointing. The dashed line coming out of the light is the
    direction. Play around with different angles and energy values for
    the sun to get different times of day in your scene.

And there you have it! Your landscape is now textured with some nice
grass to make it look a little more realistic. Play around with hill
sizes and roughness if you\'re not satisfied with your landscape, but
try not to be too picky. Nature shouldn\'t look too sculpted. Remember,
you won\'t notice a change in texture unless you render your image.

**NOTE** If you went with the suggested 100x100 grid, the rendering
process could definitely take some time depending on your system,
especially if you have ray tracing and shadows enabled. To boost the
rendering speed, go to the Scene panel (**F10**) and under Rendering,
disable the buttons that say **Shadow** and **Ray**. Also note that
because we\'ve created some hills, your camera may now be under the
terrain. Switch to the camera view (**NUM0**) to see what your camera
sees and move it if you need to.

![](Blender3DNoobToPro-Texturing_the_Terrain_03.jpg "Blender3DNoobToPro-Texturing_the_Terrain_03.jpg"){width="800"}

Join us next time as we explore how to make the landscape look even
better using texture stenciling!

## Reader Contributions

I\'m mainly doing this so the hills look better and more realistic.
Reading this will consume more time than doing it. I\'m making
everything clear for beginners. It will only take about 8 minutes more
for your hills to end up like this:

![](Blender_hills.jpg "Blender_hills.jpg")

1.  First step to achieve it is to switch from the default lamp to Sun.
    1.  You do this by clicking on the default and go to the shading tab
        (F5)
    2.  Click on *Sun*.
    3.  Go to *rotate manipulator mode* with Ctrl Alt R.
    4.  Rotate the sun until the dotted line is in your desired
        position. That is where the main energy will go. It will differ
        if you want to achieve the different time of day. You can make
        the distance greater or less with *dist.*. I kept mine at
        default 30.
2.  Now let\'s make more realistic, paler sunlight.
    1.  In the RGB slider, set R for 1, G for 1, and B for .848.
    2.  Set energy for 1.63. This will all differ for different times of
        day, so set your east and west in your head, and the later into
        the day, the further the sun to the west and the more orange.
        For midday, keep the energy on 1.63 and put the sun right above
        your hills. I set mine for earlier in the morning.
3.  Now click on the picture of a globe to change the background.
4.  Click on the *blend* button for a more realistic looking sky. On the
    left of the World toolbar, that will be the color of lower down in
    the sky and the right sliders will be the color of the top of the
    sky. Naturally, the top should be darker blue than the bottom.
    1.  It will differ for different times of the day. So you might want
        something different from this. But I set up mine for the morning
        using the settings below:
        -   The left HoRGB sliders to 0.50, 0.68, and 1.
        -   The right ZeRGB sliders to 0.11, 0.25, and 0.66.
5.  Now for the texture. *This* won\'t differ for the times of day, but
    it will differ for what type of landscape you want.
6.  Download a nice texture from google or an artists website.
    1.  Go back to Blender, go to Texture buttons (F6)
    2.  Click add new
    3.  Select *image* for the texture type
    4.  Go to the *image* toolbar, and upload the texture. Blender will
        only allow you to upload from the Blender documents, unless if
        you click on the up and down arrows on the top left of the
        screen and choose the place where you saved the texture (or
        picture).
    5.  After uploading, the X and Y repeats should be smallish, like
        6x6, so the changes aren\'t noticeable. It will look ugly in the
        preview, but it will look nice after its wrapped.
7.  Render, and 1 minute later, voila! Those are nice looking hills!
8.  Now boast in front of your friends!

**Noob Note:** You need to have your landscape selected if you are in
object mode to change the texture, otherwise it will change the texture
of the world.

## Reader Contributions 2

You can have an even better result if you use the texture to \"bumpmap\"
the mountains.

1.  Press **F5** until you are into Material Buttons
2.  Select the *Map to* tab
3.  Click on *Nor* once (the *Col* option must stay selected as well)
4.  Slide the *Nor* slider to 5 or more (might differ depending on
    texture size and repeat options)
5.  Render with **F12**

## Reader Contributions 3

Alternately from making the hill model manually, you can use a program
like L3DT. It
uses various algorithms to generate very detailed and realistic terrain
heightmaps. It also lets you edit them in a more intuitive way than
Blender does. After you have L3DT make your height map, you can export
it as a .x file, which you can import into Blender. **Noob Note:** That
can be done by going into File-\>Import-\>DirectX(.x). And there you
have a very realistic landscape mesh with a lot less work. (Noob
Question: I want to use Unity3d game engine to create a game, but i want
to use blender to create landscapes. To create massive world landscapes,
does anybody have any tips? as Unity limits any mesh to 65000 vertices,
which i\'ve already passed with my method without doing half the map.)

-If you are using unity 3d just use it for the terrain. Download the
terrain toolbox and just use .raw images. Or simply generate from there
and save. 65,000 verts is plenty btw. If you insist on using blender for
the terrain then model a high poly terrain fist consisting of around 1
mil+ verts. bake the normal map and ambient occlusion decimate your
terrain to around 10k or w/e looks good for the game. Then bam you got
10k terrain that looks like 1mil. But to be honest blender terrain
texturing is a pain compared to unity. Anyhow hope that helps.


# Blender 3D: Noob to Pro/Landscape Modeling II: Texture Stenciling

|previous=Landscape Modeling I: Basic Terrain
}}
```
## UPDATED FOR 2.7 USERS

This is a continuation of the previous tutorial, Landscape Modeling I:
Basic
Terrain.
In this tutorial, we will make our terrain look even better by using
some texture stenciling to add multiple textures where we want them in
the landscape. This tutorial assumes that you have a basic understanding
of how to use Blender (how to add/remove a mesh, how to change views,
etc\...)

## Creating the Stencil

The landscape from the previous example looks pretty good, but the
entire thing has the same texture, so it doesn\'t look very natural.
Let\'s add some rocks to those hills. If we just add a second texture to
our material, it will completely cover the previous one. What we want is
to have the first texture only show in certain places and the second
texture cover the rest. In order to do this we\'ll have to create a
stencil, which is like a mask that determines where textures appear on
the material. The stencil is a black and white image, similar to a
heightmap, except the intensity of each pixel determines how much of the
next texture will appear (black = 0%, white = 100%). I highly recommend
viewing
this
tutorial for a more in depth description of how stencils work. If you
think you have the gist, then continue on here. \[Note: Link is broken
now\] We\'re going to create our own stencil to determine where we want
rock in the landscape by \"painting\" on the object. **\*IMPORTANT\***
The next few steps will be performing temporary modifications to your
scene, so be sure to save your file before you continue so that the
changes will not be saved!! Also, if you have a subsurf modifier on the
landscape, remove that at this time as it drastically slows down the
following process.

-   Select the landscape object and switch from \"edit mode\" or
    \"object mode\" to \"**Vertex** Paint mode\". This is found in the
    Mode drop down menu, on the 3D View header. This mode lets you paint
    the object, and thereby change the color value of each vertex. When
    in Vertex Paint mode, you\'ll notice your object change color to a
    pixelated version of the texture that is applied to it. This is
    because with that texture applied, each vertex will be drawn with
    the colors you see.

**Noob Note**: Vertex Paint mode is in the drop down menu that contains
Object mode and Edit mode. Just select the object while in Object mode,
click the drop down menu, and select Vertex Paint mode from the list.

-   Switch to the Editing menu (**F9**) and you\'ll see a new tab called
    Paint. Notice the sliders labeled Opacity and Size. Opacity
    determines how much to blend the selected color with the existing
    colors when you paint. So 0.2 means that when you click, you\'ll get
    20% of the selected color mixed with whatever is currently there.
    Over on the right are different options to combine to colors. We
    want to mix, so as we paint the colors will mix together and give us
    a nice smooth blend. Size is the size of your cursor while painting,
    and thus how many vertices are affected. Keep in mind that does not
    change as you zoom in and out, so a size of 10 can actually paint
    more pixels if you\'re zoomed way out than a size of 30 if you\'re
    zoomed way in.

![](Blender3DNoobToPro-Creating_the_Stencil_02.jpg "Blender3DNoobToPro-Creating_the_Stencil_02.jpg")

-   Change the color to black and click the button that says Set VertCol
    (in 2.48 version, that button is below the color square and named
    \'SetVCol\'). This will change the color of your entire object to
    black. You\'ll notice that the object is not lit in Vertex Paint
    mode, so when the entire object is black it can be difficult to see
    where your hills are. You\'ll have to move the camera around to see
    the shapes.

\[Another newbie recommends: if you switch to the \"object\" buttons
(f7) and turn on \"Wire\" under \"Draw Extra\" in the \"Draw\" panel/tab
you should see a wireframe on top of the vertex colors you are painting,
which makes it much easier to see where the hills are. Remember to
switch this back off when you have finished painting.\]

-   Now we\'re going to paint the places where we want rock to show
    through. Change the paint color to white. It\'s less likely that
    grass will grow on steep slopes, so start painting the tops and
    edges of the steeper hills white by holding down **LMB** and
    dragging your mouse (think MSPaint). If you didn\'t heed my earlier
    advice and still have a subsurf modifier in effect, the painting
    will be very choppy, so remove that now.
-   As you\'re painting, try to make some spots pure white by going over
    them again and again, but don\'t make any one area of white too
    large as this will make a huge area be all rock, and we\'re trying
    to blend two textures.
-   This process can just be trial and error getting the landscape
    painted the way you want. Once we apply our stencil later you may
    decide there\'s too much rock in one area, or not enough in another
    and go back and change it. A few things to keep in mind:
    -   20% opacity means that most of the original texture (grass, in
        our case) will show through, so the rock won\'t be very
        noticeable if at all. You\'ll have to go over the same spots a
        few times to increase the intensity.
    -   You don\'t want a dramatic change from grass to rock, so be sure
        to blend white areas with black. That\'s why we\'re using the
        20% opacity instead of just bumping it up to 100%.
    -   Make your patches random and spotty. This will end up creating a
        more realistic effect once we combine the textures.

!Painting the stencil onto the
landscape{width="200"}

-   Once you\'re done you should have something that looks like this.
    Notice the mixture of white and black in some places, how it
    doesn\'t just go from pure white to pure black as you move down the
    hills. This will make a more natural blend and it will cause random
    rocky areas mixed in when the grass. Now we need to turn this into
    our stencil.
-   Go to the overhead view (**NUM7**) and make the projection
    orthographic if it\'s not already (**NUM5**).
-   Zoom in/out (**Mouse Wheel** or **NUM+**/**NUM-**) until the plane
    almost occupies the entire window.
-   Move the 3D cursor and any lamps or cameras away so that they\'re
    not over the landscape and take a screenshot.

!The stencil after its been cut from your
screenshot{width="200"}

-   Open your favorite image editor (I\'m a traditionalist, so I still
    like MSPaint), and cut out the image of landscape. This is now your
    stencil. Save it under your favorite format.
-   Re-open the saved version of your landscape to undo the changes we
    made to create the stencil.

So why did we make our stencil this way? This allowed us to actually
paint on our terrain so that we ensure we get the rock exactly where we
want it. Using this method, you can customize your stencil to any
object, as long as it has enough vertices. For example, if we just had a
flat plane made of 4 vertices, this technique would not have worked
because we could only paint the corners. That\'s why in the previous
tutorial I recommended using a high (but not too high) number of
vertices in your grid.

## Applying the Stencil

So now we need to apply the stencil to the landscape to mix our grass
and rock textures together.

-   Return to either Object Mode or Edit Mode (**TAB**), it doesn\'t
    matter which.
-   Go to the Texture menu (**F6**) and add two new textures in the
    material (you should already have the grass texture).
-   Make texture 2 (the first new one you added) an image and load your
    stencil from file. Do not repeat this in the x or y directions. We
    want it to map to the entire object.
-   Make texture 3 an image and load your rock texture from file. This
    one you do want to repeat, just as you did the grass.
-   Now return to the Materials menu and select your stencil texture.
    It\'s a good idea to name your textures, materials, objectives,
    etc\... so that they\'re easily identifiable.
-   With your stencil texture selected, switch to the tab labeled MapTo.
    Deselect Col (which maps the texture to the color), and select
    Stencil and No RGB. Stencil will treat this image as a stencil, and
    No RGB treats it as a black and white image. If you didn\'t select
    this second option your stencil wouldn\'t work.

!Mapping the stencil
texture

-   In the preview tab you should notice your material change so that
    the grass and rock are now mixed. If you render, you\'ll see a much
    more realistic landscape than the one from the previous tutorial!

**Noob Info:** Be sure that for the rock - texture *col* is selectet
because we want to color the landscape with the rock-texture! Otherwise
it doesn´t work. *Select Rock-Texture -\> Map To -\> col*

!Landscape with grass and rock textures
mixed

## Adding Snow

Since you already have some nice mountains, why not add some snow to
them? Adding snow is easy. All you have to do is add a fourth texture
AFTER all the others. Make this texture the same as your stencil.

-   Make sure you\'re in Shading (F5) \> Texture Buttons (F6) \>
    Textures.
-   Click on an empty panel beside Texture Type
-   Click on the little box to the left of Add New
-   Choose your stencil from the menu (hint: it helps if you name your
    textures)
-   Render and see the results.

If you made your stencil properly, you should have some nice, snowcapped
peaks. It\'s not much, but it\'s enough for a quick fix. If it isn\'t
even, you probably didn\'t make your stencil properly (meaning pretty
much all white on the peaks, and not much anywhere else). Of course,
there are better ways to do this, ways I wouldn\'t know about; I
discovered Blender merely three days before the time of writing. I leave
it up to you to see the effect: I only have so much room and bandwidth
for pictures!

This effect works by saturating the underlying color with white,
depending on the amount of white in your stencil. A light gray will
saturate it only a bit, whereas a bright, 100% white will cover it very
clearly and efficiently. If you look closely, you\'ll see that the light
gray on the stencil DOES make a difference, but it\'s not immediately
visible and requires lots of fidgeting with the Render Preview and
texture options. You might also try fiddling with the Stencil and NoRGB
option, although it worked fine for me with both turned off (I use
Blender 2.48a)

Some challenges:

-   Try to change the color of the snow. Hint: RGB
-   I\'ve yet to do this, but try making snow out of a heightmap.

## Multiple Stencils

Remember in the first tutorial when I said to leave part of the
landscape flat, because I\'d be using it later? Well it\'s time to use
it. I want to eventually use the landscape as the backdrop for a
military base, so let\'s texture the ground around where the base will
go to give it a dirt ground and road leading to it. **\*IMPORTANT\***
Just as before, the next few steps will be performing temporary
modifications to your scene, so be sure to save your file before you
continue so that the changes will not be saved!!

-   Switch to the Vertex Paint mode in the mode menu on the 3D View
    header.
-   Go to an overhead view (**NUM7**) and make the projection
    orthographic (**NUM5**)
-   Once again, paint the entire object black by selecting the color
    black in the Paint tab and clicking on Set VertCol.
-   For the next few steps, you may need to **TAB** back and forth from
    Vertex Paint mode to Object mode to make sure you\'re painting in
    the correct area. Make the opacity of the painter 1.0 and the size
    10 so that we can work very precisely.

!The stencil for our future
base{width="200"}

-   Paint an area over the flat terrain in the shape of a generic
    military base, like you see here.
-   Reduce the opacity back down to 0.2 and increase the size to 20.
-   Paint the road leading away from the base. We\'ve reduced the
    opacity and increased the size so that the road will blend more with
    the landscape around it instead of being more defined like our base.
-   Once you have your stencil looking the way you want, take a screen
    shot and save it. Then revert back to your previous environment
    (before you started painting on it).
-   Go to the Texture menu (**F6**) and add two new textures.
-   Load your stencil into the forth texture (the first new one), and
    the dirt image into the fifth texture. Once again, remember to set
    the x and y repeat for the dirt texture.
-   In the Materials menu (**F5**) select your new stencil and go to the
    MapTo tab. Deselect Col again, and select Stencil and No RGB. Notice
    the new preview.
-   Wait a second, where\'s the dirt path?!? Here\'s the problem and the
    reason I\'ve included this section: stencils are cumulative. That
    is, the first stencil defines which portions of ALL successive
    textures will be drawn, including other stencils! In order for our
    new dirt path to show up, we need to make sure it\'s part of the
    first stencil.

!Both stencils combined into
one{width="200"}

-   Open your first stencil (the one you used to add rocks to the hills)
    in your image editor and combine the new stencil with it. The result
    should appear somewhat like this. Be sure that when you combine your
    dirt stencil with your rock stencil that the dirt stencil remains
    the same size and in the same place. That is, you want the two to be
    perfectly aligned.
-   Reload your first stencil on your material, the one we used for the
    rocks. Now the preview should look the way we want it to, and if you
    render you will see your new dirt area on the flat part of the
    landscape. You can add even more stencils the same way. Here is how
    all of the textures blend together:

![](Blender3DNoobToPro-Multiple_Stencils_03.jpg "Blender3DNoobToPro-Multiple_Stencils_03.jpg")

**NOTE** I had to replace the grass texture in the above image since I
could not find the licensing information for it. I apologize for the
inconsistencies in the diagram that result from this.

Well there you have it! This is a pretty useful method of texturing
complex objects. Check out our new landscape and how it compares to the
previous, boring, single-textured landscape!

![](Blender3DNoobToPro-Multiple_Stencils_04.jpg "Blender3DNoobToPro-Multiple_Stencils_04.jpg"){width="800"}

Once again, if you have any issues with the tutorial, or feedback
(positive or negative), drop it in the discussions.

## For 2.7 blender users:

-   first you add the material
-   leave the grass texture at the default
-   add the next two textures , the stencil and the rock, soil etc
    texture as stated in the above tutorial.
-   go to the stencil texture
-   in the influence panel, uncheck col
-   check \'RGB to intensity\' button
-   check stencil
-   others everything as their default values are good

-For me, with settings above, the rock texture was not very visible. It
may help to play around with the color intensity settings in the
influence panel (increase in the rock texture, and decrease in the grass
texture) -


# Blender 3D: Noob to Pro/Landscape Modeling III: Exporting as a Heightmap

|previous=Landscape Modeling II: Texture Stenciling
}}
```
In this tutorial, I will show you how to export your beautiful terrain
to a heightmap that can be used in most 3D graphics engines. The benefit
to doing this as opposed to just exporting your mesh is that many
engines have a special process for dealing with terrains as opposed to
regular meshes where it divides the terrain up into different sections
so that it can subdivide regions closer to the camera more for greater
detail, and also cull (not render) regions outside the camera\'s field
of view, saving precious processing time. This structure is called an
oct tree and is a highly optimized way to
render large meshes such as terrains.

Before I begin, I must give credit to the Creating a Heightmap from a
Plane
tutorial on the Blender
wiki. This is how I
learned to do this trick, and most of what I will cover came from this
tutorial. I\'m simply including it here with the other landscaping
tutorials I\'ve written for convenience.

## A Word About Heightmaps

I will briefly cover what a heightmap is and how it\'s useful for those
who may not know. If you are familiar with heightmaps, you can skip
ahead to the next section.

!An example of a
heightmap{width="200"}
A heightmap is a grayscale image that uses various shades of gray to
represent different elevations across a map. Since the images are 8-bit
(with the exception of some RAW formats that are 16-bit), you have 256
different shades of gray, ranging from pure black (0) to pure white
(255). Black represents the lowest elevation on the map, while white
represents the highest. Many 3D graphics engines already have functions
to read in a heightmap and generate terrain from it. The way it does
this is it creates a grid of vertices (like we are going to do in
Blender in just a moment), and uses the heightmap to determine the
elevation of each point on the grid. The more intense the pixel color
(the closer it is to white), the higher the elevation of that vertex. In
most cases, if the resolution of the heightmap is smaller than the
resolution of the terrain, the engine will interpolate the vertices in
between those set by the heightmap. For example, if your heightmap is
256x256 and your terrain is 1024x1024, your heightmap will determine the
elevation of every fourth vertex, and the three in between will be
interpolated.

Note that these values do not represent the absolute height of any given
pixel, but rather the height relative to the rest of the map. That is,
your heightmap does not represent a landscape with altitudes ranging
from 0 to 256. When importing a heightmap, you can specify the minimum
and maximum altitudes for the map, and the whole thing gets scaled. For
example, suppose you decide the minimum is 1000 feet, and the maximum is
5000 feet. When the terrain is rendered, black pixels will represent
1000, white pixels will represent 5000, and a pixel that is exactly in
between black and white (128) will represent 3000 feet (half of the sum
of min and max). This makes heightmaps relatively flexible.

Unfortunately, as you may have already noticed, there is a limitation of
using heightmaps. Since you only have 256 shades of gray, you only have
256 possible elevations. This causes a problem. No matter how precise
your vertices may be in the mesh that you model, no matter how smooth
you may have it looking, each point will get rounded off to an integer
value between 0 and 255. When used to render a terrain, this can cause a
\"stair step\" effect as the terrain goes from one discrete elevation to
the next instead of making a smooth transition. But there are ways to
avoid this, which I will cover later.

I apologize if you\'re scratching your head right now saying \"Huh?\"
For a further explanation and example, check the Wikipedia page on
heightmaps.

## Creating the Material

!The terrain that will generate the
heightmap{width="200"}
To begin this tutorial, I will assume that you already have a landscape
that you want to create a heightmap for. If not, read my first tutorial,
Landscape Modeling I: Basic
Terrain,
to quickly create something. **WORD OF CAUTION**!!! If you\'ve already
created a landscape, try to remember the exact size of the plane that
you used. If you\'re about to make one, it\'s okay to scale the plane to
have a larger surface to work with, but REMEMBER how much you scale it
by. This will make things easier later. I recommend just working with
the default 2x2 plane or grid and zooming in on it. You may also want to
backup your scene since we\'ll be changing a few things

To create the material we need, do the following steps:

-   Remove any existing materials that may be applied to the terrain.

**Note**: to remove a material, I think you need to go to the links and
pipeline window in the shader section and click the little \"X\"
underneath the words \"link to Object\"

-   Add a new material in the Shading tab (**F5**).
-   Go to the Textures tab (**F6**) and add a new texture. This should
    be the only texture on your material.
-   From the Texture Type drop down menu, select Blend.
-   In the same window, find the Colors tab and select Colorband. This
    will let us define the blend pattern, which by default fades from
    black with full transparency to a solid cyan. Why cyan? I have no
    idea. It\'s an odd default.
-   Select the black color by clicking on the left side of the
    colorband. You should see a little black and white bar selected.
-   Increase the Alpha all the way up to 1 by adjusting the slider
    labeled \"A\".
-   Select the cyan color and change this to a solid white.
-   What you have now should look like my colorband below.

!The blend
colorband

-   Return to the Materials tab (the red ball icon next to the cheese
    looking icon).
-   In the Material pane, select the Shadeless option to disable
    lighting on the material.
-   To the right, find the pane labeled Map Input. In the bottom of this
    pane is a grid that by default reads:

**X**YZ\
X**Y**Z\
XY**Z**

-   Set all three rows to **Z** so that the texture will map entirely to
    the Z coordinate.
-   In the preview window to the left, if you select the sphere or cube
    you should see that it goes from black on the bottom to white on the
    top. That\'s the effect we want for the terrain. Remember, in a
    heightmap, black represents the lowest point and white the highest.

!Map the input to the z-axis and make the material
Shadeless

-   Finally, switch back to the Editing tab (**F9**) and click the Set
    Smooth button to enable Gouraud
    shading so that everything appears
    smooth.

## Setting up the Camera

That\'s all we need to do for the terrain itself. Now what we\'re going
to do is setup the camera in such a way that when we render the scene
we\'ll get an orthographic projection straight down on the terrain so
that we can save it as our heightmap.

-   If you still have any lights or cameras in the scene, delete them.
-   Switch to the top view (**NUM7**) and place the 3D cursor at the
    origin (0, 0, 0) by left clicking near the origin, hitting
    **SHIFT+SKEY** and selecting *Cursor to Grid*. (An easier way is:
    hitting \'SHIFT+SKEY\' and selecting \'Cursor to Center\')
-   Add a new camera, *Space-\>Add-\>Camera*. This will add a new camera
    to the scene that is looking straight down.

!The camera needs to be above the
terrain{width="200"}

-   Switch to a side view (**NUM1** or **NUM3**) and move the camera up
    the Z axis so that it is above the highest point in your terrain.
    Even though the view is going to be orthographic, and therefore
    distance doesn\'t matter, the entire terrain still needs to be in
    front of the camera.
-   Now, with the camera selected, go to the Editing tab (**F9**) and
    select the \"Orthographic\" button. This will change the camera to
    an orthographic projection which basically ignores the z-coordinate
    for all vertices (except for determining which pixels should be in
    front of others).
-   Just above the orthographic button is a value labeled \"Scale\".
    Remember earlier when I told you to remember how big your terrain
    is? This is why.
-   Change the Scale of the lens (default: 6) to match the size of your
    terrain. If you left the plane the default size, this should be 2.
    If you scaled the plane up by a factor of 20, as suggested in the
    \"Landscape Modeling I: Basic Terrain\" tutorial, this should be 40
    (the plane is initially 2 units square).
-   Now go to the scene tab (**F10**) and under Format, change the SizeX
    and SizeY to be the size you want your heightmap to be. For most
    graphics engines, this is required to be either a power of 2 (2\^n)
    or one more than a power of 2 (2\^n+1). So try something like 256
    (or 257 if you need it to be 2\^n+1).

!What the terrain will look like from the camera
view{width="200"}

-   Now, if you switch to the camera view (**NUM0**) you should see a
    \"flat\" square that completely fills the dotted box which
    represents the camera\'s field of view.

!The rendered image will be your
heightmap.{width="200"}

-   Render the scene (**F12**). You should be looking at your heightmap.
    Hit **F3** to save the rendered image and you\'re good to go!

Since this image has no color, and some engines require that your
heighmap be a grayscale image (only one color channel instead of three),
select the BW button in the Format pane before rendering. This will
render it as a grayscale image instead of a color image. !Select BW to
save as a grayscale
image.

## Avoid Stair-Stepping

As mentioned earlier, exporting the heightmap as an 8-bit image (Blender
doesn\'t support any 16-bit formats that I\'m aware of) has the drawback
that you only have 256 discrete height values which can cause a
stair-step effect when the terrain is subdivided. Ideally, you could use
an application that can export the image in a 16-bit raw format, such as
Terragen. But this is a Blender tutorial, so we\'ll not go into that. =P

### Reducing the resolution

One way you can \"smooth\" out the rendered terrain is to actually
reduce the resolution of the heightmap. This may sound counter
intuitive, but bear with me. Suppose you have a heightmap that is a
simple blend from black to white going from left to right. If your
heightmap is 1024x1024, you will get 4 columns of each height since you
only have 256 different values. In other words, your grayscale will look
something like this:

00001111222233334444\...

00001111222233334444\...

00001111222233334444\...

00001111222233334444\...

00001111222233334444\...

00001111222233334444\...

If you try to render terrain from this, you\'ll get 4 points with 0
altitude, 4 with 1, 4 with 2, and so on, creating the stair-step effect.

Now suppose you make the same heightmap, but reduce its size to 256x256.
Now you\'ll have 1 column for each height, and your grayscale will look
something like this:

012345678\.\.\.

012345678\.\.\.

012345678\.\.\.

012345678\.\.\.

You may be thinking, \"But then my terrain will be smaller, or less
detailed.\" But it turns out the opposite is actually true. Consider
applying the above heightmap to a terrain that is 1024x1024. The values
from your heightmap will be applied to every 4th vertex, and the ones in
between will be interpolated. So instead of having something like:

**0.0** **0.0** **0.0** **0.0** **1.0** **1.0** **1.0** **1.0** **2.0**

which is what you would get with the 1024x1024 heightmap, you\'ll
actually get something like this:

**0.0** *0.25* *0.5* *0.75* **1.0** *1.25* *1.5* *1.75* **2.0**

Where the integers are the values from your heightmap and the fractions
are interpolated values. This is assuming that whatever engine you are
using will interpolate the values between heights read in from the
heightmap.

At the present time, this is the only method I have verified that helps
reduce the effects of stair-stepping. As I try different techniques I
will update this page with them. For example, I know that Adobe
Photoshop can export images in 16-bit raw formats, but I haven\'t tried
it yet so I don\'t want to suggest it as a solution.


# Blender 3D: Noob to Pro/Bump Mapping

|previous=Landscape Modeling III: Exporting as a Heightmap
}}
```
Bump Maps are textures that store the relative height of pixels from the
viewpoint of the camera. The pixels seem to be moved in the direction of
the facenormals, either in direction to or away from the camera. You may
either use greyscale pictures or the intensity values of an RGB-Texture
(including images).

```{=html}

```
```{=html}

```
```{=html}

```
!**Image 1a:** A texture grid for bump
mapping.{width="150"}

```{=html}

```
```{=html}

```
framed\|none\|**Image 1b:** Material settings for the
texture.

```{=html}

```
```{=html}

```
!**Image 1c:** The texture grid applied to a sphere and to a
plane.{width="150"}

```{=html}

```
```{=html}

```
```{=html}

```
Bump Maps are easy to apply. They work well on flat surfaces, only to
some extent on curved surfaces. On curved surfaces it is more easily
noticeable that you don\'t create real 3D structures. The visible effect
depends on factors like lighting, specularity of your material, camera
angle, distance and so forth.

-   Add a new texture to your object.
-   Activate the *Nor* button in the *Map To* panel.
-   Set the depth of the bumping with the *Nor* slider.
-   Use the texture type *Image* and load your bump map.

Bump maps should contain hard transitions between black and white. A
gray wedge (e.g. a linear blend texture) would be hardly visible in the
rendering.

## Creating Bump Maps

You can easily create Bump Maps with Blender yourself, this is
especially useful if you have modeled some small details on a surface
and you realize at the end that your scene will get too complex. You
could also use the Bump Maps in a 2D application like Gimp or other,
similar programs.

I will create an animated bump map in highest possible quality, it is
not always necessary to make such an effort. The goal is to create a
wave effect and make an image sequence of it, to be used as a bump map.
The original object has 600.000 vertices, the object the map is applied
to has 8 vertices.

### Setting up the scene

framed\|**Image 2a:** Setting up camera and object in the 3D
view.

-   Open the default scene and remove the cube.
-   Insert a plane and change to edit mode.
-   Crease its edges with +1 (**Shift-E**).
-   *Subdivide multi* with 11 cuts.
-   Change to object mode.
-   Add a *SubSurf* modifier with a render level of 6.
-   Add a *Wave* modifier.
    -   *Time Sta:* -10
    -   *Height:* 0.2
    -   *Width:* 1.5
    -   *Narrow:* 1.5
-   Set the camera dead upon the plane.
    -   *X/Y/Z:* 0/0/5. You can use the *Transform Properties Panel* to
        bring the camera to a certain position, the Z-Position is
        important is this case.
-   Set the camera lens to 80.00 (*Editing Buttons-\>Camera Panel*).

The plane should now fit exactly into the camera view.

-   Save your file.

We\'re going to use the Z-Buffer information to create the bump texture.
The Z-Buffer contains the distance from the camera, this is exactly what
a bump map is. To render the Z-Buffer information as an image, we\'re
going to use *Composite* nodes. To get the highest possible quality, we
will use *Open EXR* as file format, this allows us to store the Z-Buffer
information with a numerical accuracy of 32-Bit floating point, instead
of a meager 8-Bit value.

### Render settings

-   Change to the *Anim* tab buttons (f10).
-   Set *End* to 40.
-   Activate *Do Composite*.
-   Select *Open EXR* in the *Format* panel, set *SizeX/Y* to both 600
    (square image for the square plane).
-   Set the *Output* directory to *//BumpAnim/*. This creates a
    subdirectory to the file where the image sequence will be stored.
    Don\'t omit the slashes.

### Node editor

framed\|**Image 2b:** Composite Nodes setup to render the
Z-value.
Now the setup for the composite nodes.

-   Open a *Node Editor* window.
-   Select *Composite Nodes*.
-   Activate *Use Nodes*.

A *Render Layer* and a *Composite* node will be inserted automatically.

-   *Add-\>Vector-\>Map Value*.
-   Connect the *Z*-Output of the *Render Layer* to the *Value* input,
    and the *Value* output to the *Image* input of the *Composite* node.

If you render now the image is plain white, we have to talk a bit about
the *Map Value* node. The *Offs* value is the distance from the camera
where the Z-Buffer should start (in negative BU). It is not to important
to get the best range, because we use OpenEXR, but if you would like to
use PNG instead, you have to select this value carefully.

-   Set *Offs* to *-4.8*. This is the smallest distance from the camera
    needed. You can measure this value if you use the *Camera Clipping*,
    or if you render and move your mouse with pressed **LMB** above the
    render window.
-   Set *Size* to 4. The size value is a bit complicated. This is not
    directly the value range, instead $range = \frac{1}{size}$, and
    $size = \frac{1}{range}$.
    -   If you want to include the Z-Values from -4.8 up to -5.05 the
        range is 0.25, so *Size* is 4.
    -   If you want to include the Z-Values from -4.5 to -3.5 the range
        would be -1, so *Size* would be also -1.
    -   If you want to include the Z-Values from -4.5 to -5.5, the range
        would be 1, so *Size* would be 1.

```{=html}

```
-   Render the animation.

## Applying the animated bump map

!**Image 3a:** The Bump Map applied
Video.{width="300"}

-   Open a new file.
-   Select the default cube and change to the *Texture* buttons.
-   Use the texture type *Image*.
-   Load the first OpenEXR-Image from the directory where you have
    stored the sequence.
-   Activate *Sequence* in the *Image* panel, set *Frames* to 40.
-   Change to the *Material* buttons.
-   Activate *Nor* for the texture and set the *Nor* slider to 25 in the
    *Map To* panel.
-   Set the mapping to *Cube* in the *Map Input* panel.

This is it. Pretty much the same look as with the real deformation, but
using much less resources.


# Blender 3D: Noob to Pro/Normal Mapping

|previous=Bump Mapping
}}
```
*`<small>`{=html}Noob Warning: This technique is best used for models
and animation, and is not well used and applied in the Blender Game
Engine`</small>`{=html}*

Normal Mapping in 3D graphics development is the process of using an
RGB color-map to create a three-dimensional
relief on a two-dimensional plane. The source for the normal map in
blender can either be a texture already installed in Blender, or using
an external picture-file (.jpg, .jpeg, .bmp, and so on) and loading it
as a normal map. One great aspect of Blender and normal maps is that
Blender can very easily be used to **create** normal maps that can be
turned around and used in blender to reduce poly count. This tutorial
will show the various ways to create a normal map and how to apply
different normal maps to your model in Blender.\
![](example_normal_texture_1.jpg){width="230"}
![](example_normal_texture_2.JPG){width="230"}
![](example_normal_color_map.JPG){width="230"}\
\
Sections within Chapter:

1.  Texture Normal Mapping
2.  Color Map Normal Mapping


# Blender 3D: Noob to Pro/Texture Normal Mapping

|previous=Normal Mapping
}}
```
## The Texture-Normal

To familiarize yourself with normal maps and how they work, we will
begin by using the texture engine in Blender to create our first normal
map. This process is very useful for creating quick and non-specific
normal maps for your projects that need a bit of texture.

To begin, open blender and whatever your basic load settings are, in the
3D view, delete everything so the field is clear.
( to select all, then
 to delete)

Move the 3D cursor to the center of the X,Y, and Z axis
( *Cursor to Center*, and switch
to top view () orthographic view
(). `<s>`{=html}Hit
-
then CKEY to center your view now`</s>`{=html}. *Toggle Quad View*,
 or menu *View-\>Toggle Quad
View*

![](Clear_Blender.jpg "Clear_Blender.jpg")

Add a mesh plane to the field, and scale that plane to five times normal
size. (, select
*Add-\>Mesh-\>Plane*,  then
 to scale five times size.) This plane
is going to be our base-it will remain untextured so it can be used as a
comparison. Don\'t give it a material.

Now, with the 3D cursor still on the center, add a mesh cube to the
field. Scale this cube 3 times in the X and Y directions, and 0.5 times
in the Z direction. (, select
*Add-\>Mesh-\>Cube*, ,
, then
 to scale 3 times in X and Y
directions, ,
, then
- for Z.)
This cube will serve as our texture comparison.

![](Blender_w_cube.jpg "Blender_w_cube.jpg")

For this tutorial, lets use the \"Musgrave\" texture to make a 3D
relief.

Select the cube, and then in the Buttons Window select the material
index. Give the Cube a material, and make this material any
_light_ color you wish to differentiate it from
the base plane (darker colors won\'t show the relief that well). Now
select the texture icon in the material window. Add a new texture, and
make that texture Musgrave with the following settings :

![](blender_w_cube_musgrave.jpg "blender_w_cube_musgrave.jpg"){width="350"}

-   Type: Multifractal
-   Dimensions: 0.5
-   Lacunarity: 3
-   Octaves: 2
-   Intensity: 0.45
-   Noise:
    -   Basis: Voronoi F2
    -   Size: 0.075
    -   Nabla: 0.025

Excellent, now we are ready to show what we have done! If you return to
the material window in the material index, then you will probably be
wondering what\'s wrong-your preview window just shows a sphere with a
huge purple splotch! Don\'t worry, we just haven\'t applied the texture
as a normal map yet, it\'s still just a color map. Click the \"Map To\"
tab in the material window and you will see a whole row of buttons,
menus, and sliders. Currently on the top row of buttons the \"Col\"
button is depressed, which is how the texture knows to apply as a color
map. Click the \"Col\" button to remove the color from your preview
window. Now click and depress the \"Nor\" button and look what happens!
An intricate texture embeds itself on the sphere in the preview window.
The Musgrave texture has caused a depression texture within the preview.
If you happen to click the \"Nor\" button again, you will see the
letters turn yellow and now that means the Musgrave texture is causing
an elevation texture. Click it once more and the texture is turned off.
Keep the \"Nor\" button depressed for this tutorial.
![](Texture_material_tabs.jpg "Texture_material_tabs.jpg")

Now that you know how that works, let\'s see what it did to your cube.
First, go to front view (numpad-1) and zoom out a bit so about 10% of
the screen is filled with your cube. Select the cube and hit
Shift-S-key-4-key then C-key to center your view. In the upper-left
corner, add a sun-lamp (Shift-A-key, Add-\>Lamp-\>Lamp). Adjust the
\"Dist\" Slider to a very far length, to make sure it reaches the cube.
In the upper-right corner (make it a little closer to the cube) add a
Camera (Shift-A-key, Add-\>Camera).

Move the Camera to get a better perspective of your work, by rotating it
to look at the cube and the plane. If you want exact directions: Switch
to top view (numpad-7). Move -4 Units in Y direction. Rotate -75 degrees
on Z rotation. Rotate -45 degrees on Y rotation. Now hit numpad-0 to see
how well pointed it is to the cube. Make adjustments to your own work if
you\'d like.

Now you are ready to Render and see how it turned out!
![](Blender_render_texture.jpg "Blender_render_texture.jpg"){width="250"}

After your first render, I\'ll let you know that you can adjust the
depth of the shading. Select the cube, and in the material index in the
\"Map To\" tab, in the mid-right area, there is a slider called \"Nor\"
that should be set at 0.5. Just to test, set it to 0 and render to see
what happens. Then set it to 2 and render to see the results.

After you see it rendered, you probably realized that the edges of the
cube were very sharp and didn\'t have the rocky texture. This is because
the 3D relief on the cube is fake\--it\'s not actual 3D, it\'s the
computer just calculating where light should bounce off and in what
direction. Imagine how many faces it would have taken to create this
texture shading without Normal Mapping.

If you want, you can move the lamp around and see how the light moves
around the fake-bumps.

![](Extra_examples.jpg "Extra_examples.jpg"){width="350"}

This is best if you just need a non-specific texture, such as asphalt,
cement, carpet, or even fabric. Now if you want to do something like
make a low-poly brick wall, you will need to a specifically-tailored
normal map for such thing. The next section will show you how you can
make your own normal map and apply it as well.


# Blender 3D: Noob to Pro/Color Map Normal Mapping

|previous=Texture Normal Mapping
}}
```
## The Color-Map-Normal

For more advanced Blender users, you probably have at one time or
another wanted to create something very detailed and realistic, only to
realize that one modeled head or one cool building has taken an enormous
amount of memory, and rendering (or worse, animating!) something like
that would probably take days! Well there is an awesome trick you can
use to create intricate details and design shading, with a relatively
low amount of faces. You can use blender to create and apply normal
maps, which are RGB colored maps that can be used as a texture to
calculate how light will bounce of an objects surface. All you need is
blender and photo-editing software to tweak the picture a bit.

## Creating a Normal Map

You can very easily create a normal map once you figure out all the
necessary settings. You can start by either making a high-poly count
version of your object, or making the material that will be applied to
the object to make the normal map.

### High-Poly Version

We will first start by making a simple object with a high-poly count.
Start up blender, and let\'s delete everything there first, then go to
top-view, orthographic, and start by adding a camera.

![](Clear_Blender.jpg "Clear_Blender.jpg"){width="250"}

Next, start with a circle, with a radius of 2 and 32 vertices in
circumference. Keep it filled. Select the edges of the circle, keeping
the inner vertex unselected, and extrude edges only. Scale the new
vertices by 1.1. Repeat this with only the outermost vertices 6 more
times, until you have a ring of 7 vertices and a center vertex. Now, we
will refer to the center vertex as center, the innermost ring as Ring 1,
and the outermost ring as Ring 7. Deselect all vertices, then select all
vertices of ring 2, 4, and 6 (This can easily be done by holding the Alt
and Shift keys, then selecting an edge adjoining two vertices of the
same ring for each ring). With these rings selected, move it 0.4 in the
Z direction. Now, let\'s smooth this bowl out. In the editing index,
under the modifiers tab, add a subsurf modifier of 2, and then apply the
modifier. Then under the links and materials tab, select Set Smooth.
Next after the object looks all nice and smooth, select your Camera and
move it positive in the Z direction so it\'s positioned directly above
the object looking straight down at it, and edit the camera Lens
properties so that it is set to Orthographic, and scale the lens so that
it includes all the bowl and fills up the camera space as much as
possible.

![](Blender_bowl.JPG "Blender_bowl.JPG"){width="250"}

### Creating the Color-Map Material

Now, to be able for the Render to apply the colors on the right areas of
the object. For this, we will start by applying a material the bowl.
Make this material 0.0 on the R, G, and B spectra, and depress the
shadeless button. Now, go to the textures index and add 3 textures to
the material, and set them as \"Blend\" textures with \"Lin\" depressed
(a linear calculation). For these 3 textures, name them something to do
with either \"Red\"/\"Green\"/\"Blue\" or \"X\"/\"Y\"/\"Z\" in that
order, because doing this will ensure you keep the channels in order.
The following image will show _all_ settings that
need to be set to make the material work.

![](3_norms_material.jpg "3_norms_material.jpg")

Now before your Rendering you want to make the World texture to be
completely black, so this way it won\'t interfere when you apply it as a
normal map. Now Render your image, and hit F3 to save. It should come
out to something like this.
![](Ripple_disc_norm.jpg "Ripple_disc_norm.jpg"){width="500"}

As a final note in this subsection, what I suggest doing is deleting the
bowl and saving the file as something like \"BlenderForNormals.blend\"
so if you ever want to make another normal, the area and materials are
already set up and all you need to do is import or create the object.
Just a suggestion.

### Applying as a Normal Map

Well we got the image, now let\'s apply it and make it come out as a low
poly-count texture. So, let\'s continue by deleting the high poly bowl
and instead add a plane in the middle of the camera. Now, apply a
material to the object and make the material hard, soft, rocky, wet, or
however you want it to look. After you\'ve made the plane how you want,
add a texture to the material, and make it an image texture. Load the
image as the texture, depress the normal map button, and set the normal
spacing to object. Now, on the materials index under the Map To tab,
make sure the Col button is relieved and instead depress the Nor button.
Just add a lamp above the plane, and Render! You should now have the
same shading effect as the original bowl, with about 0.01% of the
original faces\--one.

If your Render comes out odd, it may be because the shading is being
applied too heavily. You can alter this by adjusting the Nor slider
directly below the \"Mix\" drop-down menu. O used about 0.2 and it came
out just fine, like this picture.

![](Blender_plus_norm.JPG "Blender_plus_norm.JPG"){width="350"}

***Congratulations, that\'s all there is to normal mapping. It\'s a
simple technique with many great uses!***


# Blender 3D: Noob to Pro/Nodes

|previous=Color Map Normal Mapping
}}
```
Blender's *Node Editor* lets you assemble various processing blocks
(*nodes*) into combinations which feed data to one another along
connections that you specify to produce complex effects. These effects
can be used in three different ways: as textures, as materials, or for
compositing. The Node Editor makes different kinds of processing blocks
available, depending on which of the three kinds of effects you are
producing:

-   Texture nodes
-   Material nodes
-   Compositing nodes


# Blender 3D: Noob to Pro/Texture Nodes

|previous=Nodes
|subcat=Advanced
}}
```
Texture nodes allow you to produce textures that are the result of
complex computations. This tutorial will just scratch the surface of
what's possible.

## A Simple "Rainbow" Texture

Start with a new Blender document. Delete the default cube. Add a new
plane object. In the Material context in the Object Properties window,
click the icon to the left of the material name to assign a material to
the plane (there should already be a default unused one called
"Material"). In the Texture context, there should already be a texture
called "Tex" assigned to this material. Now split the area showing the
3D view into two side-by-side areas. In the right-hand area, bring up
the Node Editor. In its area header, you should see a group of 3 little
icons next to the menu
![](Blender267NodeEditorTypeIcons.png "Blender267NodeEditorTypeIcons.png");
click on the middle one for Texture Nodes. You will see appear, further
along the area header, a popup menu containing the names of the textures
so far created in your document: this should be showing the name "Tex"
of the texture you assigned to the material for your plane object. And
to the right of that, there should be a checkbox titled "Use Nodes".
Check that, and you should see a pair of initial nodes immediately
appear in the editor: an *input* node titled "Checker" and an *output*
node titled "Output", with an editable field in it containing "Default".

There must be at least one output node in the texture definition; the
data fed to this will make up the final texture. The names you assign in
the Name field will appear in the Texture context in the Object
Properties window, in a popup menu titled "Output:", with one item for
each output node. Initially this may show "Not Specified": change it to
"Default".

Each node window has little coloured circles (terminals) on its left and
right edges; the ones on the left edge (if any) are inputs for feeding
data from other nodes, and the ones on the right edge (if any) are for
supplying data to other nodes. Thus, output nodes have no outputs
(they're the final destination for the data), while input nodes have no
inputs. Other node types represent intermediate stages in the
processing, so they will have both inputs and outputs.

Back in the Node Editor, click on the titlebar of the "Checker" node
window and use either  or
 to delete it. Note that, unlike
deleting objects in the 3D view, there is **no** confirmation popup: the
node immediately disappears. (Of course, you can use
 to undo operations in the usual
way.)

Now go to the "Add" menu (or use the usual
 shortcut), find the "Input"
submenu, and select the "Coordinates" item. This will add a new input
node, which just produces the unadorned texture coordinates as its data.
The newly-added node will follow the mouse around; press
 once you have moved it to a convenient
place. You will see the new node has one output terminal, titled
"Coordinates". Left-click on this, and drag to the input terminal in the
Output window with the word "Color" and a small rectangular colour
swatch next to it. Voilà! A line (effectively a wire) should appear
connecting the two terminals, and you should see the big square colour
swatch in the Output window change from black to a whole rainbow of
colours. That's your texture!

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

If you make a wrong connection, you can move or cut it by dragging the
output end of the wire away from the input terminal it is attached to
with , to either a new input terminal or
simply into an unoccupied space between nodes; when you let go the
button, the wire will attach to the new input terminal in the former
case, or disappear in the latter case.

At this point, you should be able to hit
 to render, and you will see your plane
object with the rainbow texture applied. You can see why I chose a Plane
object: being flat, the entire texture is visible from one camera angle.

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

## Scalars Versus Vectors

The wires carry numbers between nodes. These numbers can be of two
kinds: a *scalar* is a single real quantity, like "0.5", while a
*vector* can consist of two, three or four scalars in a sequence, like
"(0.5, 0.75, 0.2, 1.0)". The number of components in a vector is also
known as the *dimension* of the vector. Two-dimensional vectors can be
used to represent texture coordinates, while three-dimensional vectors
can represent positions in space. Colours can be represented with 3
dimensions (R, G,B or H, S, V) or 4 dimensions (RGB or HSV plus alpha
channel).

Some nodes operate on scalars, while others operate on vectors. And
there are nodes where some terminals input or output scalars, while
others input or output vectors.

Try this. To the above Coordinates and Output nodes, add a "Separate
RGBA" node (under the "Color" submenu of the "Add" menu). Feed the
output from the Coordinates node to the "Color" input node of the
Separate node. Now connect just the "Red" output terminal from the
Separate node to the output node (if you move the newly-created node on
top of the existing wire, this should happen automatically):

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

See how the Output swatch shows just a greyscale ramp running from black
on the left to white on the right? This shows how the first dimension of
a vector is interpreted as the red component in an RGB colour, but as
the X coordinate in a position. Remove the output from the Red terminal
(delete the existing wire), and take it from the Green terminal instead
(by dragging a new wire from Green to the Color terminal on the Output
node); now you will see the ramp going from black at the bottom to white
at the top. The second dimension of a vector is the green component in
an RGB colour, and the Y coordinate in a position.

The terminals have different colours to remind you what type of data
they *should* be used for (purplish for coordinates, yellow for colours,
grey for scalars), but **as far as Blender's Node Editor is concerned,
colours and positions are not actually different types.** Both are
vectors, and one can be interpreted as the other. This can be (ab)used
for some creative effects! For example, the name of the "Separate RGBA"
node says it's for separating an RGBA colour into its components, but
here we are using it to take apart a coordinate vector instead.

Note also in the above, that the Color terminal on the Output node
expects a vector RGB colour, but when you feed it a single colour
component (i.e. a scalar), it simply replicates it the necessary number
of times to make a vector of the required dimension. Since all
components of the RGB colour are the same, you get a shade of grey.


# Blender 3D: Noob to Pro/Material Nodes

|previous=Texture Nodes
}}
```
Material nodes look very similar to texture nodes, and indeed there is a
fair amount of overlap in functionality. Some important differences are:

-   Functions for performing spatial transformations (e.g. rotation and
    scaling) are only available for texture nodes.
-   Functions for altering diffuse versus specular colours and rendering
    parameters, like translucency, are only available for material
    nodes.

## A Simple Graduated Material

First of all, let's set up a really basic modelling scene to show off
the node-based material you'll be creating in a moment.

Open a new Blender document, with the default cube, default light and
default camera. Create a plane object. Rotate and position that so it
lies behind the cube from the camera's viewpoint. Scale the plane up to
say, 4x, to form a decent-sized backdrop. Assign it a new default
material, and a texture with some detail to it; I used a simple Marble
with default settings, except under the "Map To" miniwindow I changed
the colour to a medium grey from the default magenta, to stop it hurting
my eyes.

Now select the cube. Scale it 3x in the Z-axis; the elongated
proportions should show off a gradation more nicely. In the "Material"
miniwindow, set the "Col" (diffuse) colour to white, and the alpha to
zero. In the "Mirror Trans" miniwindow, turn on "Ray Transp" and set the
"IOR" to some suitable refractive index, say 1.5 for glass.

Hit **F12** to do an initial render, just to confirm you've got
everything nicely arranged.

![](MaterialNodesRenderBefore.jpg "MaterialNodesRenderBefore.jpg")

With the cube still selected, open the Node Editor. By default, the
Material Nodes mode should already be selected, and the combo box should
be showing the name of the material you assigned to the cube; select it
if it's not. Click the "Use Nodes" button, and immediately two node
windows should appear, a Material one and Output one.

Click on the title of the Material node window, and use **XKEY** or
**DEL** to get rid of it. Go to the "Add" menu, "Input" submenu, and add
a new "Geometry" node. Also add a new "Extended Material" node. And from
the "Convertor" submenu, a new "Separate RGB" node. In the middle of the
Extended Material node window, there is a popup menu showing you the
names of the materials in your document; select name of the material you
previously assigned to the cube again.

Make sure there are no wires running between any of the nodes; now run
one from the "Color" output terminal on the Material node to the "Color"
input on the Output node, and one from the "Alpha" output on the former
to the "Alpha" input on the latter.

Notice that, next to each of the input terminals in the Material window,
there is either a field for entering a scalar value (grey terminals), or
a button which pops up a little set of controls for letting you specify
X, Y and Z components for a vector (blue terminals), or a colour swatch
which pops up to let you pick a new colour (yellow terminals). This way,
you don't have to make connections to all the inputs, or indeed any of
them; any unconnected inputs will be set to the constant value that you
specify.

Anyway. connect a wire from the "Global" output of the Geometry node to
the "Image" input of the Separate RGB node. "But geometry isn't a
colour!?" I hear you cry. But as explained on Texture
Nodes, a vector is a vector. Feeding in a
position instead of a colour to Separate RGB means its outputs are not
the R, G and B components of the colour, but the X, Y and Z components
of the position. So run another wire from the B (i.e. Z) output of
Separate RGB to the Alpha input of the Extended Material window. The
resulting layout should look like this:

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

Now you're ready to render. But before hitting **F12**, hit **JKEY** to
switch render buffers. That way you still have the previous render to
compare with. Once the render window comes up, you can hit **JKEY** to
alternate between the two renders.

Here's what my node example looked like (note I turned the energy of the
lamp down to 0.5, otherwise it seemed too bright):

![](MaterialNodesRenderAfter.jpg "MaterialNodesRenderAfter.jpg")

Notice the gradation of transparency along the Z-axis, from fully
transparent at the bottom to fully opaque at the top.

For added fun, try taking the material Alpha setting from the R or G
outputs of the Separate RGB node instead, just to see the gradation
orient along the X or Y axes.


# Blender 3D: Noob to Pro/Compositing

|previous=Material Nodes
}}
```
**Compositing** is the combination of multiple sources of visual input
into a single, final image. This is common functionality in expensive,
commercial video editors. Some of these (such as Adobe After Effects)
use a layer-based compositing engine. Others (such as Apple Shake, The
Foundry\'s Nuke, and eyeon fusion) use a more powerful node-based
compositing engine. Blender features a very advanced and powerful
compositing engine through the use of the Nodes Editor window. Although
the challenge of learning to use nodes may seem intimidating, it can be
very rewarding because of the professional-looking final products that
can be easily produced.

## Compositing Example

In this tutorial, we will see how compositing, combined with *render
layers*, can produce some effects that are difficult or impossible to
achieve just by straight rendering of a 3D model.

Start with a new Blender document. For a change, let's use the default
cube. Assign it a new material. Keep all the settings at default, but in
the Shading panel, set the Emit value to 1.0 and give it an interesting
diffuse colour.

Go to the Render context
![](Blender255RenderContextButton.png "Blender255RenderContextButton.png"),
look for the Post Processing panel, and check the "Edge" box. This will
draw a black outline around all objects. If you hit
 to render right now, you should see
something like this:

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

So far, not very exciting. Now go to the Render Layers context
![](Blender267RenderLayersContextButton.png "Blender267RenderLayersContextButton.png").
You should see there is already an initial default layer called
"RenderLayer". If you look in its Layer panel, you should see checkboxes
indicating all the passes of the rendering process to include in this
layer. Look for the "Edge" checkbox, and uncheck that. Now click the
 icon next to the list of layers, to add a
new layer. Look in its Layer panel, make sure "Edge" is checked, and
*un*check all the other checkboxes in the "Include:" section.

Now open up a Node Editor window, and look for the three icons to the
right of the menus, showing what kind of nodes to edit:
![](Node_Tree_Types.png "Node_Tree_Types.png"){width="60" height="60"};
click on the middle one (if it's not already selected) to enable
compositing nodes. Now check the "Use Nodes" box to the right of it. You
should now see the initial default node setup, with a single Render
Layers node feeding the initial default render layer directly to the
output:

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

Add another Render Layers node. From its layer popup menu, select the
second render layer you created, the one producing the edge outlines
(which should be called "RenderLayer.001" if you didn't change its
name).

Now, add a Blur node (Filter submenu of the Add menu). The default
Gaussian kind of blur will do fine. Put nonzero values (e.g. 1) into the
X and Y fields (otherwise the blur Size value will have no effect). Give
it a Size value of, say, 20. Connect the Image output of the first
render layer (the one doing everything except the edge outlines) into
its Image input.

Add an Alpha Over node (from the Color submenu of the Add menu). Feed
the Image output from the Blur node into its *upper* image input, and
the Image output from the second render layer (the one producing the
outline edges) into its *lower* image input. Leave the Factor at its
default 1.0. Connect the Image output of this Alpha Over node to the
Image input of the Composite node (the final output).

When you are done, check that your connections look like this (remember,
the exact positions of the nodes are unimportant, except for clarity;
what's important is the connections between them):

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

The effect of this is to blur the rendering of the cube (apart from the
edge outline), and then put the edge outline back on top of it. If you
hit  to render now, you should see
something like this:

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

## Things to Try

What happens if you put different values into the X and Y fields of the
Blur node? Try making the X value different from the Y value.

What happens if you get the inputs the wrong way round into the Alpha
Over node?

Try the other blur types available from the menu in the Blur node.

## Other Tutorials

Composite Nodes Video Tutorial (2.49b):
<http://www.youtube.com/watch?v=AAnxoJsdAAM>\
Vector Blur Tutorial (2.49b):
<http://www.youtube.com/watch?v=qY4WcNgEXv8>

Depth of Field (DOF) Using Composite Nodes (2.49b):
<http://www.youtube.com/watch?v=HBomEv-bEtw>


# Blender 3D: Noob to Pro/Hacking Blender

|nextText=next module:
"Introduction to Game Engine Source"
|previous=Advanced Tutorials/Advanced Game Engine/Game Creating Techniques(Python)
|previousText=previous module:
"Game Creating Techniques(Python)"
}}
```
Blender is an **Open Source** project. That doesn't just mean you get to
use it for free, you also get to see how
it works, and you can even make your own changes and share them with
others.

Blender is also a large software project (well over a million lines of
code), with a great many active contributors over a lifespan of more
than a decade, and it continues to be developed at a rapid rate. This
can make things somewhat intimidating for less-experienced programmers.

This unit assumes you have some decent programming experience under your
belt. Blender is mainly programmed in the
C "wikilink"), C++ and
Python programming languages. It can be built
using either the CMake or
SCons build systems.

## Getting the Blender Source Code

The official Blender source is kept in Git
repositories located at `developer.blender.org`. There are actually
several separate repositories:

-   blender-main --- the
    main part of the Blender source, excluding most Python addons.
-   blender-addons --- the
    Python addons included in the standard Blender distribution.
-   blender-addons-contrib
    --- additional useful Python addons.
-   blender-translations
    --- localized language translations for text messages.
-
-   blender-tests
    --- some interesting example `.blend` files used for testing and
    demonstrating Blender functionality.
-   blender-dev-tools ---
    tools that are useful for performing maintenance tasks on the
    Blender source, but are not actually needed for building Blender.
-   blender-cloud ---
    looks like a framework for offering a new cloud-based Blender
    service.

## Layout of the Blender Source

Say you've checked out a copy of the main Blender source tree. The top
level looks like this:

-       --- files used during the build process

-       --- top-level control file for CMake

-       --- note about Blender licensing (GPLv2)

-       --- documentation files, among them:

    -           --- the format of `.blend` files

    -           --- how to build Blender, and hack the build system

    -           --- the man page

-       --- non-Blender-specific libraries, primarily developed elsewhere,
    included in the source

-       --- simple build script for those who can't be bothered to go
    through the CMake setup process

-       --- libraries which are non-Blender-specific but primarily developed
    here, also glue code for interfacing to external libraries not
    included in the Blender source. Notable subdirectories:

    -           --- Constructive Solid Geometry routines

    -           --- the Cycles renderer

    -           --- the fluid simulator

    -           --- Blender's platform-independent GUI (including
        platform-dependent implementations). See

        for a more detailed description.

    -           --- thread-safe memory management with consistency checking

    -           --- the Inverse Kinematics library

    -           --- the library for simulating smoke and flames

-       --- additional files to be included in the Blender distribution,
    including GUI icons and fonts

-       --- top-level control file for SCons

-       --- the main part of the Blender source, further divided (ignoring
    the `CMakeLists.txt` and `SConscript` files which you will find just
    about everywhere) into

    -           --- the bulk of the source, of which some useful parts are

        -               --- low-level stuff for file management, geometry
            algorithms, sorting and suchlike

        -               --- core Blender-specific code (no UI stuff)

        -               --- code for reading and writing `.blend` files

    -           --- some additional files for building the Blender Player
        executable

    -           --- the Blender mainline

    -           --- the Blender Game Engine

    -           --- some files specific to the Windows build

    -           --- some test scripts

### Common Subdirectory Layout

Within many of the subdirectories in
 and
, you will see the following
pattern:

-   A bunch of `.h` files in the directory, and
-   an `intern` subdirectory.

The `.h` files define the functionality exported to other modules, while
the `intern` subdirectory contains the `.c` or `.cpp` files that
actually implement the module. Sometimes the `.h` files are put into an
`extern` subdirectory instead of the upper directory level.

(And yes, these meanings of `intern` and `extern` are not the same as
the meanings of `intern` and `extern` at the top directory level.)

## Blender's "Genetic Code": "DNA" and "RNA"

You will find references to "DNA" (or "SDNA") and "RNA" throughout
Blender's source code. The analogy to the terms from genetics is weak at
best, but what they refer to is:

-   "DNA" or "SDNA" ("structure" DNA?) is the system for mapping
    Blender's in-memory data structures to the on-disk `.blend` file
    format. A `.blend` file is little more than a memory dump, which
    makes it quick to write. However, the file needs to be readable by
    Blender builds on machines with different
    endianness, 32 versus
    64-bit pointers, etc, not to mention future
    versions with different capabilities. Thus, the saved `.blend` file
    includes a detailed description of the layout of all the data
    structures saved in the file, and this description is stored in the
    "DNA1" block at the end. This block is generated by the `makesdna`
    tool, which is built and run automatically as part of the overall
    build process, so its output can be included directly into the
    Blender executable. It parses all the `.h` files in the directory
    , so all
    data structures that could get saved into `.blend` files must be
    defined here, and they must be careful to use a limited subset of C
    that the parsing tool can handle.
-   "RNA" defines the Python interface to Blender's internal data
    structures and routine calls.

Here
is Ton "Mr Blender" Roosendaal explaining DNA and RNA.

## Special Globals: "G" and "U"

There is a frequently-referenced global variable named "G", of type
`struct Global`, declared in
.
The variable is defined in
.
This same file also defines the global "U", of type `struct UserDef`,
declared in
.

## Naming Conventions

Some (but not all) global symbols have prefixes on their names
indicating (roughly) where they come from. Here is a partial list.

+---------+----------------------------+----------------------------+
| Prefix  | Meaning                    | Where Found                |
+=========+============================+============================+
| AUD\_   | audaspace sound library    |
-       (see

    for an overview)

-
-
## See Also

-   Building
    Blender
    --- platform-specific instructions on the Blender Wiki
-   Development resources at
    `blender.org`, including
    -   Architecture
        overview
    -   Official developer blog
-   Mailing lists


# Blender 3D: Noob to Pro/Intro-GE-Source

|previous=Hacking Blender
}}
```
Mission Statement: The purpose of this section is to show a programmer
how to make sense of the blender game engine source code. It is not
intended for those who cannot code in C++. If you\'re one of the people
who have a basic understanding, I\'m being careful to use keywords that
if you google, should provide enough information to understand.

When you press P, several things are sent to the GE before anything can
be done. What might these be?

    StartKetsjiShell(struct ScrArea *area,
                  char* scenename,
                  struct Main* maggie1,
                  struct SpaceIpo *sipo,
                  int always_use_expand_framing)

```{=html}

```
Blender uses a lot of structs and classes. You need to have a working
understanding of these as well as inheritance before we can move on. For
a refresher:
<http://www-numi.fnal.gov/offline_software/srt_public_context/WebDocs/Companion/cxx_crib/inheritance.html>

**The SCA_IObject class**

and

This class encapsulates a lot of other things, so we can start here and
move downwards to the things that it controls. First off it uses vectors
to store all the different Sensors, Controllers and Actuators that are
linked to the object. *A vector is like an array, but it is dynamic and
has built in functions.*\
We will begin by examining how sensors are added.

\
`typedef std::vector<SCA_ISensor *> SCA_SensorList;`\
`SCA_SensorList m_sensors;`

The first line here is a typedef so it just tells us that we can create
a vector of SCA_ISensor by using the name SCA_Sensor list.\
The second line creates the vector with the name, m_sensors

`<font style="color: blue">`{=html}

    void SCA_IObject::AddSensor(SCA_ISensor* act)

    {   m_sensors.push_back(act);   }

`</font>`{=html}

This function allows the parents of an SCA_IObject to add new sensors by
calling: SCA_IObject.AddSensor(keyboard); *pseudocode*\
\
So now you know how Objects in the GE create sensors (and actuators and
controllers, its the same :) So lets look at how Sensors are grabbed!
Since they are dynamically added the program can\'t make assumptions
about how many are there or what they will be. Thus there is this helper
function:\
`<font style="color: blue">`{=html}

    1''SCA_ISensor* SCA_IObject::FindSensor(const STR_String& sensorname)
    2{
    3   SCA_ISensor* foundsensor = NULL;
    4
    5   for (SCA_SensorList::iterator its = m_sensors.begin();!(its==m_sensors.end());its++)
    6   {
    7       if ((*its)->GetName() == sensorname)
    8       {

    9           foundsensor = (*its);
    10          break;
    11      }
    12  }
    13  return foundsensor;
    14}''

`</font>`{=html} Put simply, you give this the name of a sensor and it
returns a pointer to the sensor.\
\
for the newbies: I know you learned all about classes when i asked you
to, but just in case:) the first word, \"SCA_ISensor\*\" this tells us
that the function will return a pointer to a SCA_ISensor. And based on
the functions arguments, we know that when you call FindSensor you must
give it a string between the parenthesis.\
in line 3 you create an empty pointer which you will use to store the
sensor that you find. Then you loop and go through each sensor in the
vector of sensors (remember, it was named m_sensors) until you find the
one that matches the name. If you don\'t find one, you return NULL.

**void SCA_IObject::Suspend(void)** What this does is it loops through
all of the sensors and sends each one a \"suspend\" call. What this does
is change a variable named, \"m_suspended\" which makes stops the
sensors from running when they are called with their Activate()
function.


# Blender 3D: Noob to Pro/Tutorial Links List

|next=Hotkeys
|subcat=Reference
}}
```
This page includes a categorized list of
Blender "wikilink") tutorials written or
spoken in English. This is by no means a comprehensive list of
tutorials, so adding links is encouraged. For tutorials that are not in
English, please refer to the About page.

If you would like to learn about editing pages, you can find information
in the Introduction to
Wikipedia.

## General Blender Information

-   Blender
    Documentation -
    Includes information on Blender functionality, developing for
    Blender, and creating Addons.
-   To Those Learning
    3D -
    Recommendations for people first diving into Blender.

## Blender Tutorial Websites

This section includes links to websites that host multiple tutorials or
provide links to other Blender tutorials. This section does not contain
links to individual tutorials.

-   BlenderGuru - Run by Andrew Price,
    BlenderGuru includes free tutorials as well as full training
    courses.
-   Blender Cookie - Part of the CG
    Cookie Network. Includes many free tutorials. Other tutorials and
    full courses are available to members with a subscription.
-   BlenderDiplom - Free tutorials
    mostly focused on visual effects, but includes other topics as well.
-   Blender Tutor - Includes a series
    for Blender beginners as well as tutorials for more advanced users
-   BlenderArt Magazine - Blender magazine
    that includes tutorials in each issue.
-   Blenderpedia - Free video tutorials,
    mostly about creating scenes and environments.
-   3D Total Blender
    Tutorials -
    Includes many tutorials about various topics in Blender.
-   BlenderCourse - 120 page
    Blender E-Book created for Blender 2.63
-   Tutorials For Blender3d -
    Many Blender Game Engine tutorials for Blender 2.6
-   Blender Tutorials Vimeo
    Group - This group the
    collects video tutorials posted on Vimeo.
-   Super3boy\'s Blender
    Tutorials -
    Video tutorials dealing with the basics of different aspects of
    Blender.
-   Greybeard\'s Blender Video
    Tutorials - Downloadable video
    tutorials that go over many topics.

These sites include links to Blender tutorials on other sites

-   BlenderNation
    Tutorials -
    List of tutorials that have been posted on BlenderNation
-   Blender3d Club - Includes links to
    various Blender tutorials
-   SurfnLearn.com : Blender 3D
    Tutorials -
    Links to various Blender Tutorials
-   Learningblender.com - Categorized
    links to various Blender Tutorials

These sites include tutorials that use Blender versions prior 2.5.

-   Dave Jarvis\' Blender
    Tutorials - Free tutorials
    using Blender 2.4x
-   Kator Legaz - List at bottom
    includes a couple Blender tutorials
-   BlenderMasters -
    Links to tutorials and some embedded YouTube tutorials. All 2.4x and
    older.
-   Selleri (Link removed, because it is harmful nowadays) - Handful of
    tutorials on a very old version of Blender.
-   Cogfilms Tutorials - PDF
    downloads of tutorials in 2.4x
-   Pavaler.se - A couple of
    tutorials on modeling and animation.

## Blender Interface

-   Blender Basics: 2 Minute Tutorials - The
    Interface
-   Blender Interface Theme
    Repository
-   Basic
    Editing
-   Blender Hotkeys
-   Changing Views
-   First Impression
-   Getting Started

## Modeling

### Mesh Modeling

-   Video - DupliVerts
    Tutorial
-   How to solve Blender\'s smoothing
    problems:
    discussion about smoothing strategies: Smooth/Solid, Auto Smooth,
    EdgeSplit modifier\...
-   Heightmaps
-   Extrusion Controlled by
    IPO
-   Basic objects
-   Modeling Techniques and
    Strategies
-   Easily Remove Orphan Edges and
    Vertices
-   Non-destructive bevel
    effect

### Nurbs and Subsurface Modeling

-   Subsurf modeling
    2
-   Metaballs
-   Abstract SubSurf modeling
    I

### Modeling Specific Objects

-   Wooden Crate
-   Double-Helix
-   Turtle
-   Leaf
    Shader
-   Sears-Roebuck Dairy Barn
-   Golf
    Ball
-   Celtic
    Knot
-   Quick and Easy
    Tree
-   Ice Cube *(pdf
    tutorial)*
-   Water I (Link removed, because it is harmful nowadays) *(pdf
    tutorial)*
-   Water II (Link removed, because it is harmful nowadays) *(pdf
    tutorial)*
-   Dice
-   Die with round
    corners
-   Logo
-   Cutting through
    steel
-   Candle
-   Landscape Cartoon (Link removed, because it is harmful nowadays)
    *(pdf tutorial)*
-   Text
-   Hair
    Tutorial
-   Wikipedia: Human Body Proportions

## Texturing

-   Video - Basic
    Materials
-   Making a Lightsaber with
    Halos
-   The Unofficial Texturing
    Tutorial
-   Material Indice
    Tutorial
-   Transparency and
    Refraction
-   Reflections
-   Texturing landscapes according to
    slopes
-   Using Texture
    Stencils
-   Textures with
    Alpha
-   Textures with
    Bumpmapping

### UV Mapping

-   2 Minute Tutorial: Blender Basics - UV Mapping (Project from
    View)
-   Video - UV Mapping
-   UV Mapping &
    Texturing
-   Complex material for a
    sword

### Animated Textures

-   Video - Changing Colors Of Objects Mid
    Animation
-   animating masks for simulating ice
    freeze
-   Animated Procedural
    Textures *(pdf tutorial)*

### Texture Nodes

-   Video - Blender Nodes
-   Vector Blur usage with
    Blender

### 2D Texture Painting Techniques

These tutorials do not directly involve Blender, however they cover
useful 2D knowledge for advanced Blender users.

-   Steven Stahlberg\'s
    Tutorials
    `<span style="color:green;">`{=html}\* exposed`</span>`{=html}
-   Fixing Lighting Irregulaties in Self-Tiling
    Maps
-   Texturing with
    Gimp

## Lighting, Shadows and Rendering

-   2 Minute Tutorials: Blender Basics - An Outline of Lighting and
    Rendering in Cycles
-   Basic 3 Point
    Lighting
-   Radiosity I
-   Radiosity
    II
-   Ramp
    Shaders
-   Simulating
    Radiosity
-   Ambient
    Occlusion
-   Soft Shadows and Area
    Lights
-   Soft Lights (Link removed, because it is harmful nowadays)*(pdf
    tutorial)*
-   Blender\'s
    Mist

## Compositing

-   Matching Real
    Lighting

## Animation

-   Video - Animation
    Basics
-   Simple
    Animations
-   Effects
-   Walking Blues
-   Non Linear Action Editor - NLA
    I
-   Non Linear Action Editor - NLA
    II

### Armatures and IK

-   Video - Basic
    Armatures
-   Dancing
    Flor
    `<span style="color:green;">`{=html}\* exposed`</span>`{=html}
-   Animation Workshop
    II
    `<span style="color:green;">`{=html}\* exposed`</span>`{=html}
-   Animation recode
    project
-   Action Constraints tutorial made
    easy
-   Driven Hand
    Rig
-   Constrained
    Mechanics
-   Ikas Blender 3D -
    Introduction

## Particles

-   Video - Particle
    Basics
-   Video - Grass with
    Particles
-   Video - Explosions with Particles and the Explode
    Modifier
-   Particle
    Interaction
-   Static
    Particles
-   Making a Rain
    Effect
-   Setting a prey-predator relationship using Boids
    particles
-   Particle and field
    basics

## Fluid Simulation

-   Video - Fluid
    Simulation
-   Fluid Simulation Basics

## Game Engine

-   Video - Blender Game Engine
    Basics
-   Video - Making Dominoes
-   Game Engine
    Development
-   New fully integrated game
    engine?
-   #GameBlender
-   Walkthrough
    Tutorial
-   Mouse Look 1st Person. Options include capping, invert mouse pitch
    and adjust mouse
    sensitivity.
-   Viewports. Creating a split
    screen.
-   Python game functions. Sample Code Included. Updated to
    2.48
-   Car Setup. Use Bullet Physics vehicle
    wrapper.
-   Python scripting for the Game
    Engine
    at cgmasters.net.
-   Python scripting series of
    tutorials

## Verge3D

-   Video - Verge3D for Blender
    basics

## Python and Plugins

-   Povanim Export
    Script
-   AI Path
    Importer
-   3D-No Plugins; Put your 3D Blender space on
    web!
-   Randomizer
    Script
    Scroll down the page
-   Different Useful Scripts (Link removed, because it is harmful
    nowadays )
-   Lsystem tree
    maker
-   Python API
    Introduction
-   Python API, Making a Square
    Mesh
-   Python API,
    Iterations
-   Python API, Automating Vertex
    Creation
-   Python API, Automating Face
    Creation
-   Python API, Making
    Potatoid
-   Python Script, To build an Empty for
    EnvMap
-   Python Script, Bezier Curves
    Import
-   Python Script, Paths
    import
-   Python Script, Importing Adobe Illustrator
    Format
-   Python Script, Mesh
    Explosion
-   Python Script, Level Of
    Detail
-   Python Script, Wire Shadows and
    extrusions
-   Python Script, Changing the active camera
    instantly
-   Using the Superficial Scattering
    Script
-   City Block
    Genarator
-   Blender Camera Calibration with Live
    Camera
-   Mesh shaker and tutorial
-   Batch
    STL
-   Vertices to a Curve
    Converter
-   Zutils, Z-Buffer
    Utilities

## Related Programs

-   YafRay
-   SPE - Python IDE for Blender
-   Wings 3D Subdivision Modeler
-   Verse Gimp-Blender
    Plugin
-   Kerkythea Renderer
-   Equinox 3D
-   Povray
    export
-   Adobe Illustrator Paths
    import
-   Inkscape SVG
    import
-   Voodoo Camera
    Tracker
-   Lionhead The
    Movies

### Distributed Computing

-   BURP - Big and Ugly Rendering Project
-   Global Rendering-Farm

## Blender WikiBooks

-   Blender 3D: Blending Into
    Python
-   Blender 3D: HotKeys
-   Blender 3D: Import and Render a SolidWorks
    Model
-   Blender 3D: MemoBook
    `<span style="color:green;">`{=html}\* exposed`</span>`{=html}
-   Blender 3D: Noob to Pro

## FAQ

-   Blender
    FAQ
    (Generated on September 24, 2001)

## Miscellaneous

These are must reads for CG artists.

-   How to succeed in Animation
-   Classical Film and Video Knowledge Base
-   Quick Tips in Design&GFX

### Open Movies

-   NaNo - Blender Internet Virtual Movie
    Studio

### IRC

-   <irc://irc.freenode.net/blender>
-   <irc://irc.freenode.net/blenderchat>
-   <irc://irc.freenode.net/blenderclasses>
-   <irc://irc.freenode.net/blenderqa>
-   <irc://irc.freenode.net/blendercoders>
-   <irc://irc.freenode.net/blenderwiki>
-   <irc://irc.freenode.net/gameblenderdev>
-   <irc://irc.freenode.net/gameblender>
-   <irc://irc.freenode.net/verse>

### Tests

-   Blender Benchmarks

## Other Lists

Please read more about on
talk page.

-   `<big>`{=html}**LANGUAGES
    (czech)**`</big>`{=html}

## About

This links list is language filtered and extended version of personal
collection originally provided by **IamInnocent**. So if you looking for
tutorials in other languages check this link at
www.elYsiun.com.

-   German Blenders should have a look at
    <http://de.wikibooks.org/wiki/Blender_3D:_Tutorial_Linkliste>

If you want to add Blender tutorial link in some other language you can
add it temporary on
talk page. We will
later made such WikiBooks in other languages too.

Thank you all who contributed to this nice and useful links collection!
Feel free to add your name or link if you think you need to be mentioned
here.