Learn how to use Dynamic Topology Sculpting in Blender

The dynamic topology system in Blender allows for a much more organic, creative sculpting process. It gives you much more flexibility in not only how, but what you sculpt by not limiting you to the original starting basemesh.

When working with dynamic topology, Blender will automatically tessellate the mesh under your brush stroke to account for the detail needed. This gives you the ability to add detail anywhere you wish, create new forms, and work with a much more optimized polycount since the tessellations are localized.

Check out CG Cookie Citizen for more sculpting training

To learn more about using dynamic topology in your workflow and creating finished sculptures I recommend you check out Kent Trammell’s training series on Creature Modeling For Production, and his Citizen course on Hard-Surface Sci-Fi Weapon Sculpting.

Learn how to automate tasks in Blender with Python scripting

There are lots of things we do over and over again in a normal workflow. It might be that you need to add and apply a modifier to a hundred objects, or change the display traits of many objects, or any other repetitive task. These things add up quickly and increase the time it takes to finish our project. Luckily for us Blender has a complete Python API  that allows us to access most of Blender’s tools and settings via scripting.

Python scripting in Blender is straight forward and relatively easy to learn but it can be very confusing if you don’t know where to start. In this tutorial I will take you through the process of writing a very simple script that allows you automate adding and applying Subsurf modifiers to all your selected objects.

The techniques you’ll learn in this tutorial can be applied to many, many different tasks in Blender. I am only scratching the surface of Python scripting in Blender in this tutorial.

 What you’ll learn:

Below you can see the final script that you’ll be learning how to write. I’ll be showing you how to write it and what each part is.

import bpy

scene = bpy.context.scene
selected = bpy.context.selected_objects
object = bpy.ops.object

for obj in selected:
    scene.objects.active = obj

    object.modifier_add(type="SUBSURF")

    for mod in obj.modifiers:
        if mod.type == "SUBSURF":
            bpy.context.object.modifiers[mod.name].levels = 2
            object.modifier_apply(apply_as="DATA", modifier=mod.name)

Find more scripts

You can check out more scripts from the CG Cookie Crew via our GitHub repository: https://github.com/CGCookie/script-bakery

Vehicle Modeling Course in Blender

The Vehicle Modeling DVD was released in the first quarter of 2011, after the Intro to Blender and Character modeling series. It was our first physical DVD ever shipped and has shipped more than any other training DVD we’ve ever produced. However, now that the series has reached the ripe age of 2 years, it is being inducted into the CG Cookie Citizen library, making it accessible to all Citizen members.

Trade the value of a couple lattes for complete access to our Citizen training library

What you’ll learn

In this intensive, mesh modeling training series, you will be taken through the complete process of modeling a very detailed, sci-fi vehicle in Blender. The series makes use of modeling sheets and concept art by David Revoy. This series is presented in such a way to be ideal for all levels of users. Each tool used is explained along the way for new users but the topics presented will intrigue even the most advanced modelers. Throughout this series you will learn extensive modeling techniques, mesh topology, and workflows for creating a manageable model in relatively little time.

Beauty renders of the final model

Included in the download

The source files for this series contain the original concept art and modeling sheets by David Revoy, a video breakdown form David himself showing how the concept came together, and all the .blend files for the final model.

Embrace the Power of F2

In this quick tip you will learn how to enable and use the F2 addon by Crouch. F2 is an extension of the F-key fill-faces function for mesh editing.  Its purpose is to increases workflow efficiency and user friendliness when it comes to filling holes in polygonal meshes.

For any Blender modelers out there, I think you will evaluate F2 as a brilliant tool that belongs in your workflow!

Additional information can be found on the Blender Artists thread.

MUSIC:  “In Peace” by Jeris

Model hard-surface objects with smooth curves and sharp details in Blender

Hello and welcome to this CG Cookie tutorial series on hard-surface modeling in Blender. Through this series I’ll be giving you a complete introduction to modeling hard-surface objects with subdivision surfaces, allowing you to create anything from vehicles, to weapons, to environment props.

Learn what you need to know to create all kinds of hard-surface objects by joining Citizen, unlocking the complete series.

In this series I’ve chosen a small, stylized airplane as the subject matter, as it provides a great example of hard-surfaces that is fairly simple but also easy to learn. The plane design is based on artwork and modeling sheets created by Tim Von Rueden at Concept Cookie. I’ll be walking you through the complete modeling process of creating this plane, demonstrating a variety of techniques and tools along the way. Among other things, I’ll be showing you box and edge modeling techniques, I’ll show you how to use various modifiers for non-destructive modeling, and I’ll take you through multiple techniques for creating sharp edges with optimal geometry. This series is presented in real-time, giving you a complete picture of of my modeling process.

Extra add-ons and themes

During this series I make frequent use of a custom add-on I developed that helps to speed up the workflow for common tasks. You can download the add-on, along with the custom them I use for Blender’s interface below:

Jay Tools: http://wiki.blender.org/index.php/Extensions:2.6/Py/Scripts/3D_interaction/jaytools

CG Cookie Theme: https://github.com/CGCookie/script-bakery/blob/master/scripts/presets/interface_theme/cgcookie.xml

Background Audio used: http://ccmixter.org/files/airtone/33469 by Airtone

Get Started with the Basics of Blender

If you’re new to Blender then you’re in the right place! Through this series I’m going to introduce you to the key basics of Blender, helping you get started with all the fundamentals that you need to begin working in Blender. This series is intended primarily for beginners that have a basic understanding of 3D.

I will be giving you a tour of the interface and navigation, modeling, animation, shading, lighting, and rendering with Cycles.

Where to go next with Blender and tutorials?

If you’ve completed this tutorial series and are eager for more training then here’s a few hand-picked tutorials just for you! To get the most value I encourage you to join our Citizen membership to get access to our complete tutorial library, including many exclusive training series that goes more in depth and cover challenging topics, like architectural visualization and and low poly asset creation.

Modeling: Modeling a Shipping Container and Modeling an M4 Assault Rifle

Animation: Intro to Character Rigging and Baker Charactering Animation Series

Physics and Dynamics: Shattering a Coffee Cup and Simulating and Rendering Fire

Texturing: Texturing a Truck Wheel and Rendering in Cycles and Introduction to Texturing in Cycles

Shading, Lighting, and Rendering: Rendering Realistic Headphones in Cycles and Rendering Stunning Long Hair in Blender

Compositing: Introduction to Compositing and Compositing Cycles Render Passes

Learn the basics of OSL scripting in Blender to create your own Cycles shaders 

One of the big new features of Blender 2.65 is the inclusion of the Open Shading Language (OSL) for the Cycles render engine. OSL has been developed by Sony Pictures Imageworks as a shading language for modern path-tracing render engines like Arnold or Cycles. The testbed for OSL, until now, has been a special version of the Arnold render engine used on the films The Amazing Spiderman, Men in Black 3, and Hotel Transylvania.

With Blender 2.65, Cycles has become the first publicly available render engine to support OSL.

Like this tutorial and want more? Consider joining Citizen for just $10 USD / month to support the site and get a PDF version of this tutorial

Introduction to OSL in Blender 2.65 – Part 3 – Integrating the Pie

This third installment of the Blender Cookie OSL introduction explains the internals of the Pie texture and how to improve the integration into the Cycles node system.

Basically an OSL shader (just like GLSL shaders and Renderman shaders) evaluates a point on a surface. The point is defined by a ray hitting the surface. It then performs a mathematical calculation on a property, like in our case the color. Consider a simple plane with object coordinates:

This is why you need texture coordinates to start a procedural texture. The shader needs to know relative to where to run the computation. The cool thing is that the shader is working like it’s doing the computations for all points simultaneously thus it works like some kind of 2D plotter. That essentially means you can use a large pool of mathematical functions to create patterns using OSL. A good tool to preview many of those functions is the Blender add-on 3D Function Surfaces: http://wiki.blender.org/index.php/Extensions:2.6/Py/Scripts/Add_Mesh/Add_3d_Function_Surface

But there is another implication. Remember how we left the turbulence-part out of the function for the final pattern? There was a good reason for this. We simply don’t need to calculate any kind of turbulence inside the shader when there is a vast variety of turbulence patterns right at our fingertips in Cycles. For example, the noise texture. If you use an external texture instead of a turbulence function from inside the shader for each point, the shader will look at the value of the external texture at that point and use it for the computation. So let’s remove one of the turbulence inputs, rename the other one to simply “Noise”. This way the user of the shader knows that they have to plug some kind of noise texture into that slot. Next, add the turb-part back to the output line:

#include "stdosl.h" 

shader node_Pie(

int Slices = 4,

float Hardness = 1,

float Angle = 0,

float Noise = 0,

point TextureVector = P,

output color Texture = 0

)

{

float angle_intern = 0;

    angle_intern = atan2(TextureVector[0],TextureVector[1]) + Angle*3.1415926/180.0;

    Texture = 0.5-0.5*sin(angle_intern * Slices - Noise - 0.5);

}

You can make the effect even stronger by adding a math node set to multiply:

Or change the appearance completely by using a different noise texture as input:

As you can see, OSL isn’t just making the writing of new shaders and textures easier, the fact that it is completely fit for data propagation through nodes is also making things a lot more versatile!

As a final brush-up, let’s remove the “Hardness” Input and the “– 0.5” at the end of the final line. The latter is simply rotating the pattern a little and not really needed:

#include "stdosl.h"

shader node_Pie(

int Slices = 4,

float Angle = 0,

float Noise = 0,

point TextureVector = P,

output color Texture = 0

)

{

float angle_intern = 0;

    angle_intern = atan2(TextureVector[0],TextureVector[1]) + Angle*3.1415926/180.0;

    Texture = 0.5-0.5*sin(angle_intern * Slices - Noise);

}

As a conclusion to this chapter for the Blender Cookie OSL Introduction here’s a comparison between the two textures in Blender Internal and OSL:

Lines of code for Blender Internal: 98

Lines of code for OSL: 15

Because OSL makes writing shaders really easy, we can expect a wealth of new shaders ported to OSL in the near future. Great times ahead for the Blender community!

There are literally thousands of shaders out there written in different shading languages that are just waiting to be ported to OSL. If you have a GLSL shader at hand and want to port it to OSL I recommend this short video tutorial by Thomas Dinges: http://www.openshading.com/tutorial-2-glsl-to-osl/

A nice resource of Renderman shaders that you can try to port to OSL can be found at http://www.renderman.org/RMR/RMRShaders.html

Additional OSL resources:

• OSL Introduction: http://code.google.com/p/openshadinglanguage/wiki/OSL_Introduction
• OSL Language Specification: https://github.com/imageworks/OpenShadingLanguage/blob/master/src/doc/osl-languagespec.pdf
• Tutorials and Links to example Shaders: http://www.openshading.com/
• Siggraph 2012 OSL Workshop Slides: http://blog.selfshadow.com/publications/s2012-shading-course/

Learn the basics of OSL scripting in Blender to create your own Cycles shaders 

One of the big new features of Blender 2.65 is the inclusion of the Open Shading Language (OSL) for the Cycles render engine. OSL has been developed by Sony Pictures Imageworks as a shading language for modern path-tracing render engines like Arnold or Cycles. The testbed for OSL, until now, has been a special version of the Arnold render engine used on the films The Amazing Spiderman, Men in Black 3, and Hotel Transylvania.

With Blender 2.65, Cycles has become the first publicly available render engine to support OSL. This has two implications:

1. There are not many code examples and ready-to-use shaders yet.
2. Easy sharing of shaders between different render engines is not working yet, but there are other render engines that plan to support OSL in the near future.

Like this tutorial and want more? Consider joining Citizen for just $10 USD / month to support the site and get a PDF version of this tutorial

Introduction to OSL in Blender 2.65 – Part 2 – Procedural Textures

This second installment of the Blender Cookie OSL introduction will focus on one aspect where OSL is really powerful – the creation of procedural textures!

Even though the Blender Internal renderer has a decent amount of procedural textures built-in, there still is a plugin system that allows programmers to write procedural textures for it. Yet, there are not very many available. A few of these can be found at http://www-users.cs.umn.edu/~mein/blender/plugins/texture.html

Go there and take a look at the Pie texture plugin. The source for it can be found at http://www-users.cs.umn.edu/~mein/blender/plugins/texture/pie/pie.c

Download it and open it with your favorite text editor. Don’t be scared by the amount of code – we’ll need only a fraction of it in order to port the texture to OSL.

 The following shows the important lines highlighted in red and green:

/* Copy lefted.

* Blablabla for the lawyers

* /

#include “math.h”

#include “plugin.h”

#define NR_TYPES 1

float result[8];

float cfra;

int do_reset = FALSE;

extern float hnoise(float noisesize, float x, float y, float z);

/* set up plugin menu */

char name[]= “Pie”;

char stnames[NR_TYPES][16]= {“Pie”};

VarStruct varstr[]= {

/* type, name, default,min,   max, tooltips */

{ LABEL, “”, 0, 0, 0, “”},

{ NUM|INT, “divs “, 6.0, 2.0, 1000.0,

“Pie plugin: Number of slices”},

/* Number of slices */

{ NUM|FLO, “hardness “, 1.0, 0.0, 5.0,

“Pie plugin: Falloff Hardness”},

/* determins sharpnes of edge, could use some work */

{ NUM|FLO, “ang ofs “, 0.0, -180.0, 180.0,

“Pie plugin: Angle offset “},

/* phase angle */

{ NUM|FLO,    “turb dep “,0.0,    -5.0, 5.0,

“Pie plugin: Turbulance depth”},

/* Pos. Turb affects ‘white’, Neg. affects ‘black’ */

{ NUM|FLO, “turb siz “,0.25, 0.0, 2.0,

“Pie plugin: Turbulance size”}

};

typedef struct Cast {

float dum1;

int div;

float hard;

float ang;

float turbd;

float turbs;

} Cast;

/* ******************************************************************* */

int plugin_tex_doit(int, Cast*, float*, float*, float*);

int plugin_tex_getversion(void)

{

return B_PLUGIN_VERSION;

}

void plugin_but_changed(int but)

{

}

void plugin_init(void)

{

}

void plugin_getinfo(PluginInfo *info)

{

info->name= name;

info->stypes= NR_TYPES;

info->nvars= sizeof(varstr)/sizeof(VarStruct);

info->snames= stnames[0];

info->result= result;

info->cfra= &cfra;

info->varstr= varstr;

info->init= plugin_init;

info->tex_doit=  (TexDoit) plugin_tex_doit;

info->callback= plugin_but_changed;

}

int plugin_tex_doit(int stype, Cast *cast, float *texvec, float *dxt, float *dyt)

{

float angle, turb=0;

angle = atan2(texvec[0],texvec[1]) + cast->ang*3.1415926/180.0;

if ( cast->turbd !=0.0 )  {     /* save time if no turb */

turb = cast->turbd * hnoise(cast->turbs,texvec[0],texvec[1], texvec[2]);

/*printf(“turb: %f\n”,turb);*/

}

result[0]= 0.5 – 0.5*sin(angle * cast->div – turb – 0.5);

if (cast->hard !=1) result[0]= pow(result[0], cast->hard);  /*Very slow, better way?*/

if (result[0] > 1) result[0] = 1.0;

else if (result[0]<0) result[0]=0;

result[4]= 1.0;

return 0;

}

 Red denotes input variables, green are the parts where the actual calculations take place. The rest is more or less stuff that is specific to Blender Internal that we will skip, since we’re using Cycles. We can also skip some of the highlighted stuff as it can be “outsourced” to other nodes in Cycles. So let’s start by creating a very simplified version of the above Pie plugin in OSL.

Let’s start by adding all the inputs to our OSL script, no matter if we use them later on or not. We can still remove or comment out inputs later on:

#include "stdosl.h"

shader node_Pie(

int Slices = 4,

float Hardness = 1,

float Angle = 0,

float TurbDepth = 0,

float TurbSize = 0.25,

output color Texture = 0

)

{

}

Note: this part looks simpler in OSL because Blender does not support Metadata yet. In later versions we’ll be able to add tooltips and Min/Max-ranges to the inputs. For now all we can define are some sockets. But that is enough for our purpose.

Now let’s have a look where all those inputs in the original code are going to. Fortunately the author of the code has used meaningful variables, as you can see in the green part at the line starting with “if (cast->hard !=1)”.

if ( cast->turbd !=0.0 )  {     /* save time if no turb */

turb = cast->turbd * hnoise(cast->turbs,texvec[0],texvec[1], texvec[2]);

/*printf(“turb: %f\n”,turb);*/

So you can already guess from the names which variable is which. The actual way the input variables are taking is through the struct {}, which maps the input variables to variables named slightly different. Then the struct is used to call the actual function that is denoted by “doit”. Fortunately we don’t need all of this in OSL, we can access the values of the input variables directly.

Let’s have another look at the first green line:

int plugin_tex_doit(int stype, Cast *cast, float *texvec, float *dxt, float *dyt)

The function does not only get the inputs which are all combined in the “*cast” but also a texture vector. In Blender Internal this was set through the mapping of the texture, in Cycles it’s another input vector. So let’s complete the inputs by adding another line:

#include "stdosl.h"

shader node_Pie(

int Slices = 4,

float Hardness = 1,

float Angle = 0,

float TurbDepth = 0,

float TurbSize = 0.25,

point TextureVector = P,

output color Texture = 0

)

{

}

Now for the first green line. It defines two variables that are used only in the computation but not as an input. Let’s start by adding the angle and not care about the turbulence at the moment. Since we already use a variable ‘Angle’, let’s call the one that is used only for computation purposes ‘angle_intern’:

#include "stdosl.h"

shader node_Pie(

int Slices = 4,

float Hardness = 1,

float Angle = 0,

float TurbDepth = 0,

float TurbSize = 0.25,

point TextureVector = P,

output color Texture = 0

)

{

float angle_intern = 0;

}

Now for the first line of computation. This is a very important line because it is the only one where the texture vector is accessed, thus the only line where something is directly drawn. All the other lines are only manipulating what was drawn in the first line.

Translating it to our OSL version is simple. The variable ‘angle’ in our case is called ‘angle_intern’. ‘Texvec’ is called ‘TextureVector’ (because it is nicer to read) and the ‘cast->ang’ is simply our ‘Angle’ input. The strange notation for the latter in the Blender Internal texture has to do with C and how certain kind of data is accessed there (pointers!). We don’t need to bother with that in OSL.

So add the following two lines to your script. The second line is just to output what was computed so we can see what’s going on in the viewport:

#include "stdosl.h"

shader node_Pie(

int Slices = 4,

float Hardness = 1,

float Angle = 0,

float TurbDepth = 0,

float TurbSize = 0.25,

point TextureVector = P,

output color Texture = 0

)

{

float angle_intern = 0;

    angle_intern = atan2(TextureVector[0],TextureVector[1]) + Angle*3.1415926/180.0;

    Texture = angle_intern;

}

If everything works correctly you will be able to manipulate the Angle-input and see the changes interactively.

Now let’s port just one(!) other line and we will have a texture that is already very versatile and fun to use. The next four lines are about adding noise distortion to the texture, so let’s skip that for now and see what the next line is doing. Some computations are done involving the number of slices and the noise that was create beforehand. If we remove the noise/turbulence from the computation we get:

#include "stdosl.h"

shader node_Pie(

int Slices = 4,

float Hardness = 1,

float Angle = 0,

float TurbDepth = 0,

float TurbSize = 0.25,

point TextureVector = P,

output color Texture = 0

)

{

float angle_intern = 0;

angle_intern = atan2(TextureVector[0],TextureVector[1]) + Angle*3.1415926/180.0;

    Texture = 0.5 - 0.5*sin(angle_intern * Slices - 0.5);

}

You can now change both the angle and the number of slices and change the texture coordinate input. If you want the texture to stick to the object use ‘Object’ as input. You can then change the position of the center of the texture using a mapping node. To get sharper stripes you can use a color ramp node which of course can also be used to colorize the stripes:

It looks like the hardness-setting is not needed at all. But what about the turbulence? The next part of the series will explain a little about the magic that is used to compute the texture and then based off this knowledge we are going to optimize the shader a little more towards usage in a Cycles node network.

Stay tuned for part 03!

Links to OSL resources:

• OSL Introduction: http://code.google.com/p/openshadinglanguage/wiki/OSL_Introduction
• OSL Language Specification: https://github.com/imageworks/OpenShadingLanguage/blob/master/src/doc/osl-languagespec.pdf
• Tutorials and Links to example Shaders: http://www.openshading.com/
• Siggraph 2012 OSL Workshop Slides: http://blog.selfshadow.com/publications/s2012-shading-course/

Learn the basics of OSL scripting in Blender to create your own Cycles shaders 

One of the big new features of Blender 2.65 is the inclusion of the Open Shading Language (OSL) for the Cycles render engine. OSL has been developed by Sony Pictures Imageworks as a shading language for modern path-tracing render engines like Arnold or Cycles. The testbed for OSL, until now, has been a special version of the Arnold render engine used on the films The Amazing Spiderman, Men in Black 3, and Hotel Transylvania.

With Blender 2.65, Cycles has become the first publicly available render engine to support OSL. This has two implications:

1. There are not many code examples and ready-to-use shaders yet.
2. Easy sharing of shaders between different render engines is not working yet, but there are other render engines that plan to support OSL in the near future.

To help support the site, and to receive a PDF version of this tutorial in the source files, consider joining Citizen for just $10 USD / month

 So what’s OSL useful for, anyways?

If you are not interested in programming whatsoever, you might want to skip this article and just use OSL shaders others provide. But wait a little. If you have ever created a complex node setup in Cycles, you already did some programming. Visual programming, to be exact. With OSL, you can create the very same shaders you used node setups for, but in text form. Think of OSL as a different view on the Cycles node system that allows some additional operations.

Let’s start with the following example:

Consider you would like an Add Shader with factor inputs for both closures so you can tweak the result just like you can tweak the Add (Mix) Node in the Blender compositor.

Using the normal Cycles nodes, you would probably build something like this node-group:

Although this does what it is supposed to do, the setup is rather hackish. Instead, we may create a clean and simple implementation in OSL that will result in a single node, serving our purpose.

To use OSL in Cycles, you need to switch the Shading System to ‘Open Shading Language”. Beware that this will not run on the GPU but is CPU-only at the moment: 

Now add a script node: 

The script node has two buttons: Internal and external. By clicking on external you will be prompted to load a .OSL-file from disk. This is the way to go if you want to use script files provided by third parties. If you want to create OSL nodes from scratch then internal is the way to go. Internal allows you to select text blocks that are stored in the current .blend. To create a new text block simply open up the text editor in Blender and click on New. Give your text file a meaningful name, like AdvancedAdd and write or copy and paste the following lines:

#include "stdosl.h"

shader node_advancedAdd(

)

{

}

Now you can select the text from the drop-down list of ‘Internal’. A message should appear “OSL shader compilation succeeded”. If it doesn’t, click on the refresh-icon. 

 Nothing has changed, but you successfully compiled your first OSL shader. What you have created is the foundation for every OSL shader, so it may be a good idea to save the file somewhere for later use.

The first line simply tells the shader to include a file called stdosl.h – which is included as an internal library file in Blender and is where most of the operations, closures and other stuff you might or might not be using is stored. In the future there might be other libraries you can include and use, but for now it’s only stdosl.h.

The next line actually defines the shader by giving it a name, followed by an open and closed bracket. Between these brackets is where you can define inputs and outputs. Let’s start by adding some inputs:

#include "stdosl.h"

shader node_advancedAdd(

float Fac1 = 0.5,

closure color Closure1 = 0,

float Fac2 = 0.5,

closure color Closure2 = 0

)

{

}

Compiling this will leave you with four new inputs. Two of them are inputs for numbers and the other two are inputs for shaders. Notice that the names we gave them are reflected on the labels of the inputs.

But this is still not of much use. To make this shader into something useful we need at least one output. Adding an output is as simple as putting the word ‘output’ before the data type:

#include "stdosl.h"

shader node_advancedAdd(

float Fac1 = 0.5,

closure color Closure1 = 0,

float Fac2 = 0.5,

closure color Closure2 = 0,

output closure color Closure = 0

)

{

}

Now we are finally ready to add the actual computation to the shader. It is a one-liner and consists of the name of the output variable/socket to which we assign the values of the two input shaders added together. Each individual input shader is also weighted with the value from the factor inputs:

#include "stdosl.h"

shader node_advancedAdd(

float Fac1 = 0.5,

closure color Closure1 = 0,

float Fac2 = 0.5,

closure color Closure2 = 0,

output closure color Closure = 0

)

{

Closure = Fac1*Closure1 + Fac2 * Closure2;

}

That’s it! Your first OSL shader is complete. In the below image you can see the final result:

As you can see, the two setups are doing exactly the same, yet for a programmer the second version is just the way cleaner approach. In the next part of this series, you will learn how to create an equally simple shader that cannot be created with Cycles nodes at the moment (unless you are doing some other hackish things).

Until then, this list of useful OSL resources will really get you up and going:

Links to OSL resources:

• OSL Introduction: http://code.google.com/p/openshadinglanguage/wiki/OSL_Introduction
• OSL Language Specification: https://github.com/imageworks/OpenShadingLanguage/blob/master/src/doc/osl-languagespec.pdf
• Tutorials and Links to example Shaders: http://www.openshading.com/
• Siggraph 2012 OSL Workshop Slides: http://blog.selfshadow.com/publications/s2012-shading-course/

Learn how to tweak Blender’s interface and customize the toolbar with simple scripting.

In this Blender tutorial Jonathan will show you how to quickly add any tool to the toolbar for easy access. This is done by accessing the python scripts that generate the toolbar and the rest of the interface. Doing this is very fast, flexible, and requires very little effort and no previous scripting experience necessary.

One of the great things about Blender is that all interfaces, menus, toolbars, etc are generated through Python scripts. These Python scripts can be accessed by simply right-clicking on a button or menu entry and choosing “Edit Source.” This will allow you to modify the script from the text editor any way you choose. By following the existing code you can easily deduce what’s needed to add new tools to the toolbar or to any menu. No previous scripting  experience is needed to follow this tutorial.

If you enjoy the freedom scripting brings then you can also check out these awesome tutorials by Patrick Boelens:

Introduction to Python Scripting in Blender

Scripting a Custom Tool Menu

Code Overview for the Baking UV Textures to Vertex Colors Add-on