OSL Goodness


(GottfriedHofmann) #1

I’m very happy with the new OSL script node - here is my first exercise, an Add Shader with a factor input (I really wonder whey the normal add closure does not have it):

#include “stdosl.h”

shader node_advancedadd_closure(
float Fac = 0.5,
closure color Closure1 = background(),
closure color Closure2 = background(),
output closure color Closure = background())
{
float t = clamp(Fac, 0.0, 1.0);
Closure = Closure1 + t * Closure2;
}



(jarope) #2

So has this been put in the lastest build now?? I really want to get playing with this.


(GottfriedHofmann) #3

Ok, first one was a warmup - for the next one I wanted to test wether it is possible to port one of these BI procedural texture plugins to OSL:

http://www-users.cs.umn.edu/~mein/blender/plugins/texture.html

Turns out it works pretty well and the result is way less complicated, as you can see with this basic pie texture:

#include "stdosl.h"

color pie(point p, int Divides, float Angle)
{
    float angle_new;
    angle_new = atan2(p[0],p[1]) + Angle*3.1415926/180.0;
    return color(0.5 - 0.5*sin(angle_new * Divides - 0.5));
}

shader node_magic_texture(
    int Divides = 2,
    float Angle = 5.0,
    point Vector = P,
    output color Color = color(0.0, 0.0, 0.0))
{
    Color = pie(Vector, Divides, Angle);
}

Stripped the GPL-Block of the code, copyright of the original version goes to Robert Wenzlaff.


Edit: I also wrote a version where you can set the colors of the stripes, but I think it’s not very usefull since you can easily set the colors with a colorramp node which also lets you adjust the hardness and thickness of the stripes with a very fine-grained control:

#include "stdosl.h"

color pie(point p, int Divides, float Angle)
{
    float angle_new;
    angle_new = atan2(p[0],p[1]) + Angle*3.1415926/180.0;
    return color(0.5 - 0.5*sin(angle_new * Divides - 0.5));
}

shader node_magic_texture(
    color Color1 = color(0),
    color Color2 = color(1),
    int Divides = 2,
    float Angle = 5.0,
    point Vector = P,
    output color Color = color(0.0, 0.0, 0.0))
{
    Color = mix(Color1, Color2, pie(Vector, Divides, Angle));
}

(holyenigma74) #4

looks confusing…
art we artists or programmers?


(DingTo) #5

It’s quite simple actually.
It gives enormous possibilities to those who want to dive into complex shaders.

If you can’t / don’t want to use it, don’t use it. :wink:


(m9105826) #6

If you’re a good 3D artist, chances are you know a bit of programming as well. I can’t think of anyone who works in a production studio who doesn’t know at least a little bit of python or MEL script, or who can’t write a simple shader for Renderman. As artists we need to be familiar with a range of tools, sometimes tools that might not be classically associated with artists. A lumberjack and a ice sculptor both use chainsaws, but you would never call an ice sculptor anything but an artist.


(ng-material) #7

Technicalities are something you just can’t escape,its the nature of computer graphics.

I don’t understand all this either.lol.

but hey,you’ll never come across a production that is made exclusively by artists or technicians,there will be a mix of both.

unfortunately some people are better technically than they are artistically (aesthetically)

there are doctors out there that know anatomy better but than anyone,but ask them draw/sculpt a human figure,lol,there’s a lot more too it than “technical knowledge”…

Gottfried has some excellent effects/tutorials on his website though,and effects simulation is somethng that requires a bit of technical know-how to get a bit more artistic control.

apologies for derailing.


(Kemmler) #8

This is pretty sweet, although I don’t tend to feel the urge to actually script my shaders very often, it’s useful to be able to.

As far as the artist/programmer question: to be good in this medium, you have to be both.


(GottfriedHofmann) #9

If you are an artist, just use the shaders others write. OSL makes the process of creating shaders and procedural textures way easier than before. Imagine a repository with hundreds of procedural textures at your fingertip, not just the ones built into Blender right now :slight_smile:


(marcatore) #10

and you can port shaders from other renderers like the next vray… just for example…


(jarope) #11

So once I get this running and get my head round making shaders my 3rd year dissertation will be a comparison of OSL vs OpenGL shaders now using Blender as the test tool!


(Daniel8488) #12

Not being a programmer I admit that this stuff seemed pretty daunting at first (It isn’t though, just read the specifications pdf on the OSL sourceforge site!). I want to use it because it looks so powerful, and like Marcatore mentions, you can port shaders from V-ray, to Arnold, to Cycles. Which, I’d imagine, will mean at some point there will be a plentiful supply of professional-grade shaders readily available on-line to either add straight to your library, or to customize to fit your own needs.

Slightly off-topic; I’ve read (or at least I understand) that in the future we will be able to do a whole lot more with OSL, going beyond shaders.


(JoHal) #13

@GottfriedHofman & DingTo:
Do you think it is possible to bring with OSL the Voroni Crackle procedural to cycles?

Johannes


(DingTo) #14

You can write all kinds of procedural texture patterns with OSL, Voronoi Crackle could be done too.


(JoHal) #15

Great news :smiley:


(Elias79) #16

Yes good news, would love to see them in a official cycles materials database that is accessed from within blender :slight_smile:


(GottfriedHofmann) #17

Another interesting thing I just discovered - the original Pie procedural had a turbulence-option to distort the pie-pieces - with OSL I changed it so you can simply use any type of noise for that - über-cool!

#include "stdosl.h"

color pie(point p, int Divides, float Angle, float Noise)
{
    float angle_new;
    angle_new = atan2(p[0],p[1]) + Angle*3.1415926/180.0;
    return color(0.5 - 0.5*sin(angle_new * Divides - Noise - 0.5));
}

shader node_magic_texture(
    int Divides = 2,
    float Angle = 5.0,
    float Noise = 0.0,
    point Vector = P,
    output color Color = color(0.0, 0.0, 0.0))
{
    Color = pie(Vector, Divides, Angle, Noise);
}



(DingTo) #18

Nice Tests Gottfried, the latest one is really cool! :smiley:

I did some tests as well.

  1. Cell Noise
    OSL has some nice inbuilt noise patterns (perlin, cell, gabor…). Here, I simply mapped the cell noise map (which is bw) to a variety of colors using the smoothstep() function.

#include <stdosl.h>

shader node_cellnoise(
    float Saturation = 0.5,
    float Value = 1.0,
    output color Color = (0.0))
{
    float Fac = (noise("cell", P));
    Color = color("hsv", (smoothstep(0, 1, Fac)), Saturation, Value);
}


There are also some converter functions to play with.

  1. Convert a Wavelength Value (in nm) to a Color.
#include "stdosl.h"

shader node_spectrum(
    float Wavelength = 600.0,
    output color Color = (0.8))
{

    Color = wavelength_color(Wavelength);
}
  1. Convert a Blackbody (in Kelvin) to an Emission Shader
#include "stdosl.h"

shader node_blackbody(
    float Temperature = 5200.0,
    output color Color = (0.8),
    output closure color BSDF = 0)
{

    Color = blackbody(Temperature);
    BSDF = Color * emission();
}

(marcoG_ita) #19

Keep posting this stuff guys! Super interesting. Little explanations for total noob in custom shading/scripting is highly appreciated too :slight_smile:

Cheers, keep it up


(zeffii) #20

is it possible to write a shader that displays the un-occluded edges of a mesh, at some thickness?