Tutorial Art Design: shader

Articles by "shader"

REVIEW / Blender OSL Book

I am currently reading this book titled "Open Shading Language for Blender" by Michel Anders. This book was first mentioned at Blender Nation blog not long ago:
http://www.blendernation.com/2013/10/30/new-book-open-shading-language-for-blender/

Finally.

The very 1st book to talk about OSL in Blender! Yey~! Here it is the first original and fresh book that properly covers OSL! This is actually quite a BIG thing, although somewhat very modest. Just like when Blender goes from 2.49 to 2.5x until today, it was MAJOR, but very MODEST.

I really like that attitude, big kudos to Blender and people like Michel.

So, I got my hand on the book, it only cost under A$10 (after all money conversions) and it worths every dollars. It may be cheaper for you depending on the strength of your currency.
https://www.smashwords.com/books/view/368598

I downloaded the epub format and reading the book on iBooks (iPad).

THE AUTHOR: MICHEL ANDERS
Let's talk about the author a little bit that I knew of (by searching on Google).

This Blender OSL book is the 3rd book that Michel self-published, as mentioned here:
https://www.smashwords.com/profile/view/varkenvarken

Apart from this original OSL book, Michel also has written an active blog on OSL:
http://blenderthings.blogspot.nl

I actually read that blog a lot during my OSL study and exploration. Many shaders over there are pretty complex though!

Michel other blog:
http://michelanders.blogspot.com.au

There is some more personal trivia about the author inside the book, which is kind of nice.

TOPICS COVERED IN THE BOOK
The book started with introduction on why you would learn to write OSL code for shading and texturing.

That question above is definitely something everyone had in mind when they stumbled into something called OSL or Open Shading Language.

Some are probably happy to just use the already provided nodes (which is alright, and can get you quite far in production), while some others get more curious and like to know more about OSL and unlock its huge potential.

From intro topic, the book quickly moves to simple practical OSL shader. It covers a bit about Data types (int, float, string, void, point like data types, array, struct).

Slowly the topics ramp into important topics like: Patterns, Vectors, Normals.

I quite like one chapter titled "Mapping vectors" which covers multiplication (Scale) and Rotation of vectors. This is very important and gladly he answered this big question I had for a very long time.

From then on, Michel goes into specific simple procedural textures and shaders like the basic Checker texture, Polka Dots, before soon we get to more exotic and interesting shaders: Leopard shader, Diamondplate, etc. I have to admit that some shaders are pretty sophisticated.

Michel will give you "warning" whenever we are dealing with Math inside the shader. Math is something that often scares the artist, but we should not be because computer will do the complex calculation based on certain formula, we just need to set it up. So that is the idea that I still tell myself every now and then.

In between shader examples, he will go through and break down the Math behind it. There are thing like Symetry operations concept that explain how we can create a complex texture by mirroring it.

There is one chapter that talks about Splatter shader, where we could use our own PNG texture and randomly stamp the images, here is an example usage using my own coin.png texture (it has Alpha):

With the book, he also provided the working example files, the OSL files and Blender files. Over 80+ shaders given for you to use and to study.

MY VERDICT
I have to say that I am very happy to get hand on this book. It helps me a lot to put together my OSL knowledge so far in place. If I have time to revisit my older post on OSL, I could make the code more efficient followint the example structure of Shader shown on the book.

It is very inspiring for me. Maybe one day I write and publish my own book as well.

Many other books that talk about procedural textures (mostly for Renderman) goes really complex, too fast. But this one slowly explains what important and covers the foundation to help you move.

Similarly to myself, I think Michel put big emphasis on the procedural texture design and creations. OSL can actually do a bit more on top of procedural texture creations, however the most fun bit is the texture creation.

This book is MUST HAVE book in your library for any Shader Artists who has interest in learning OSL or shader writing in general.

MATTER OF CODING AND PROGRAMMING
Again, I have to give encouragement for "artist" who never write code before, since writing OSL shaders involves creating functions and goes further with Computer Graphics theory.

Programming ... is not hard, it just takes time to learn. I was afraid of any coding few years back, which I wish I had not been.

Just like I used to have fear of cooking and used to order foods from restaurants or just cook instant noodles in the past, well... apparently cooking from raw ingredients is not that hard.

Surely, we cannot create amazingly delicious foods at the beginning. But by time and with time, we eventually can.

Watch some movies like these for inspirations (fairly off-topic, but to make a point):
- Jiro: Dream of Sushi
- Taishoken: God of Ramen

And you will figure out soon that many of "amazing works" out there are simply taking some time to create and every skill takes dedication and passion (and obsession) to master.

I don't know what path of programming you will go through from ZERO to HERO, but I am sure you will find a way to overcome any obstacle if you continue not to give up. Remember you can always ask and there are always some nice people out there will answer when you are stuck.

Many of solutions are out there. In fact, many of tools to help you are out there as well.

Processing Programming Language
Start here:
http://www.imaginary-institute.com/blog/author/andrew/
http://funprogramming.org/
But also read some great books out there on Processing.

ChucK Music Programming -> NEW!
https://www.coursera.org/course/chuck101
http://chuck.cs.princeton.edu

There is also Pure Data, Super Collider, and Max (node based).

DESIGN BY NUMBERS by John Maeda
John Maeda's book DBN and tool to learn visual programming is a must read and explore.

Python Programming
http://learnpythonthehardway.org
And many more sources on Python. Remember that inside Blender, we already have Python to play with on any computer at any time. If you use Mac or Linux operating system, you already have Python. Even Raspberry Pi computer has Python!

There is a joy in continuosly learning and discovering, and if you are in Computer Graphics, never stop learning.

OTHER STUFFS
Crazy WebGL Mario at Shader Toy:
https://www.shadertoy.com/view/Msj3zD

OSL / Wooly Mummy OSL

Up until today, I believe I have spent over 100+ hours to study about OSL (Open Shading Language). I believe that's a good first steps for someone who never wrote Shaders before.

Maybe this shader can also be called Mummy OSL Shader.

I know I am still very much a beginner in Shader Writing. There are still plenty of things about OSL that I honestly do not understand. For most of part, I understand it in certain way, but maybe someone in the future will correct me or help me to understand it better.

I am still confused about Closure in OSL, for example. So far, I am only dealing with Procedural Texture creation in OSL.

With better understanding of the code, I think we can create our own Closure. However, we can actually mix and match the pre-built closures like Diffuse, Glass, Glossy, etc. within a single node. Lots of power. But I think before we get there, I like to focus with procedural Texture creation and design.

This post is a little intermezzo to note down what I have learned so far on OSL, how I got this far. Hopefully if you are also starting to write OSL from zero, you can pickup a thing or two.

TEXTURE CREATIONS: NODE OR CODE?

Things are surely a lot easier when we connect nodes to create Shader, right? Cycles Node Network is brilliant as it is, so easy to use to create beautiful render using the built in nodes. It is quite a robust system already.

The additional Script Node that allows us to write our own node using OSL is even making Cycles in Blender more amazing. It is not yet GPU accelerated as of today, OSL is still CPU only render, but I still find it pretty fast and great to try ideas.

Interestingly enough, I found that whenever I rewrite a snippet of code that actually recreates the same thing of what the built-in node can already do (Noise, Voronoi, Cellnoise, etc), I gain a little more layers of knowledge.

I figure that a lot of interesting procedural textures are all based on Noise function. By layering Noise function, we create turbulance. And turbulance texture itself is really good powerful for adding details.

With a bit of knowledge of shader writing, it is as if now I am starting to be able to see better, to break down and to think about Texture (procedurally or non procedurally) in more details and also simplified at the same time.

Shader writing (RSL, OSL, GLSL, etc) is really quite challenging area but also rewarding experience. Perhaps shader writing is not for everyone, but you should try first.

As a prequisite, it helps to know a little bit about programming (Python is my basis, but I knew a bit of MEL scripting which is a little bit like C) in order to learn to write and code shader. Good grasp of programming concept should be ok to get you started in shader writing.

I remember the first time writing OSL, by following and rewriting code that is shown by other great Blender Artists and Developers out there.

Thomas Dingto
Geofrey..

RSL to OSL

"I have to learn and understand RSL (RenderMan Shading Language) in order to understand OSL!". That is the sentence that kept telling myself whenever I am stuck.

There are materials out there that talk about Shader Writing. I tried to read and digest all the available RenderMan books at the library that I (am lucky enough) to have access to. Some of the RenderMan books are already pretty dusty and many years old.

Here are list of the books I could find at the UTS (University of Technology of Sydney) Library:

The RenderMan Shading Language Guide
Advanced RenderMan: Creating CGI for Motion Pictures
http://www.larrygritz.com/arman/materials.html
Essential RenderMan
Rendering for beginners : image synthesis using RenderMan
The RenderMan companion : a programmer's guide to realistic computer graphics

I probably can grasp about 25-30% of those materials, I have to re-read them again in the near future if I need to get deeper.

There are so many amazing RSL Shaders I discover along the way.

Some shaders are SIMPLE but very CLEVER and actually a good exercise for beginner:

Bowling Pin
Pencil
Ruled Paper
Watermelon
Banana
Woods

The issue with learning RenderMan is ACCESS to it. Like everything in life, often it is all about ACCESS to the tool and the materials.

I am currently using Pixar Photorealistic RenderMan (PRMan) to dig RenderMan. I happened to have access to it, thanks to one nice guy from Pixar. Since I have this privilege, I definitely MUST take this opportunity to study and use the tool while I can.

However, if one does not have access to PRMan, 3Delight is a good alternative.

It is only recently that I look into RenderMan properly and its latest development with their Physically Plausible GPShaders (General Purpose Shaders), I can see how things have changed over the years. PRMan implementation inside Maya is fantastic. It is really a lot easier to get a highly realistic render.

ONLINE SOURCES FOR RSL AND OSL

Ok, so apart from those great legacy books on RenderMan to read, there are plenty of online materials that are really helpful.

Pixar's documentation of RenderMan:
http://renderman.pixar.com/resources/current/rps/rslFunctions.html

Although RSL is not OSL, they have similarities.

This online note by Steve May (Pixar) actually the one that finally clicks with my brain.
http://accad.osu.edu/~smay/RManNotes/index.html

Malcolm Kesson's priceless RSL materials at FUNDZA
http://www.fundza.com/

Inigo Quilez notes and YouTube
http://www.iquilezles.org/www/articles/distfunctions/distfunctions.htm
http://www.iquilezles.org/www/articles/functions/functions.htm

Check ShaderToy:
https://www.shadertoy.com/

MY FIRST SHADER: OSL Wooly

I hope that this shader is pretty original.

This took nearly 3 hours to render... but looks quite nice.

It is very simple actually, started with just 2 stripes, originated from this RLS shader:
http://accad.osu.edu/~smay/RManNotes/RegularPatterns/transitions.html#cross_tile

I also found some hints from:
http://www.fundza.com/rman_shaders/surface/index.html
http://www.fundza.com/rman_shaders/displacement/index.html

I figure that I could introduce 2 kind of "randomization". We don't really use random function in shader writing I think.

Let me quote Larry Gritz from OSL Developer Thread:

"I can't really think of a good use for random(), since you can't guarantee the order of shading, it wouldn't be stable from run to run. The only thing I can think of is for use in sampling, but (a) the whole point of OSL is that you don't need to be doing sampling in the shader anymore, and (b) even if you did, it would be better for us to think of a way to provide specialized functions that were reproducible and better-stratified than just having a uniform RNG.

As for hash(), the idea there was something like the cellnoise trick. What I had in mind was just using a strong has on the floating point bits of whatever you passed in (like the hash we use on the integer lattice values to generate infinite, non-repeating cellnoise values).

Since nobody seems to care enough to notice that these are unimplemented, I'm fine with removing them from the spec. We can always add them back if we decide that there is a legit use case. "

The "random" and "details" can apparently come from:
1. Random color per object.
http://blenderartists.org/forum/archive/index.php/t-277986.html
2. Random by multi-layering the same texture using simple loops.

This one post from BlendBits actually has snippet of "random function" using Cellnoise function.
http://blendbits.blogspot.com.au/2013/05/lens-flare-shader-for-blender-cycles.html

Champagne Gold with lots of Colors stripes. Sounds familiar?

Wooly OSL Shader is very simple. Just repetition of lines that is rotated slightly. It is a 2D texture.

Maybe with the same idea, we can create Pokemon Ball OSL Shader.

Here, at BlenderThings blog, again it introduces one shader that uses "randomization".
http://blenderthings.blogspot.com.au/2012/12/a-hagelslag-sprinkles-osl-shader-for.html

Out of curiosity, I often plug one OSL Shader into another Shader. In this case below I plug the Sprinkles OSL into my Wooly OSL Shader:

Interesting cartoony style NPR shader, not perfect, but has potential.

Shaders that are using multi-layers randomization is indeed slow to render, but looks nice and detailed. With Blender, "slow render" is not an easy, we can always have unlimited render farm.

Over one hour and still rendering a single frame...

I tried combining this shader with pre-built nodes in Cycles:

TAKING WOOLY OSL SHADER TO THE NEXT STAGE

At current stage, I think Wooly OSL Shader is still a work in progress. I would like so that each line is more 3D like thread, with a bit of shadowing whenever it overlaps layer below it.

I think some OSL experts out there can probably take it to high level production ready shader.

These concepts below are crucial to understand and able to write OSL:

PROGRAMMING CONCEPT >> Variable declaration, Loop, ....
STRUCTURE & CONSTRUCT >> we can write OSL in whatever way we like, however without proper planning, we could easily get lost with the code. following a good construct and having a plan will help us to have manageable and flexible reusable code.
MATH & BASIC FUNCTIONS: sin(), cos(), atan2(), smoothstep(),
INCLUDE >> When you see word INCLUDE, usually that is when we source some snippet or macro or helper functions that is bundled as external file.
LAYERS & BLENDING >> I only found this concept quite recently and I would like to implement my previous OSL writing so that every "shape" or "texture" created procedurally can be easily layered on top of one another.

REWRITING THE WOOLY SHADER FROM SCRATCH...

The whole code is like this:

THE CODE: WOOLY OSL SHADER

(TO BE CLEANED UP)

/* ALL HELPER FUNCTIONS COME BEFORE THE ACTUAL SHADER */

void rotate2d (
float x,
float y,
float rad,
float ox,
float oy,
float rx,
float ry
)
{
rx = ((x) - (ox)) * cos(rad) - ((y) - (oy)) * sin(rad) + (ox);
ry = ((x) - (ox)) * sin(rad) + ((y) - (oy)) * cos(rad) + (oy);
}

color blend(
color a,
color b,
color x
)

{
return ((a) * (1-(x)) + (b) * (x));
}

float pulse (
float a,
float b,
float fuzz,
float x
)
{
return (smoothstep((a)-(fuzz), (a), (x)) - smoothstep((b)-(fuzz), (b), (x)));
}

/* THE ACTUAL SHADER CODE BELOW */

shader crosstile(
float rot = 45,
color Cs = color(1.0),
color Os = color(1.0),
float fuzz = 0.05,
int seed = 231,
int iteration = 10,
vector Pos = P,
output color Oi = color(0.2),
// output color Ci = color(0.2),
output color Col_Out = color(0.5)
)
{
// we have to do this in OSL
// becayse we do not have Global Variable s and t
float s = Pos[0];
float t = Pos[1];

// background layer
color surface_color = Cs;
color surface_opac = Os;

// initialize layer
color layer_color = color(0.1);
color layer_opac = color(0.2);

/*
// vertical bar layer
layer_color = color(0.1,0.5,0.22);
layer_opac = pulse(0.35, 0.65, fuzz, s);
surface_color = blend(surface_color, layer_color, layer_opac);
*/

// THANKS FOR CODE SNIPPET
// http://blendbits.blogspot.com.au/2013/05/lens-flare-shader-for-blender-cycles.html

// Generate repeatable sequences of 'random' numbers - based on nrand and seed settings.
float nrand = 0;

// Random helper function
float urand () {
   nrand += 1;
   return cellnoise(nrand, seed);
}

// multiple rotating bars with random values
float ss;
float tt;
float power;
for (float i=0.0; i<iteration; i++){

// want random
float Random=0;
float R=0;
float G=0;
float B=0;
getattribute("object:random", Random);
R=trunc(Random*100.0)/100.0;
G=trunc((Random*100.0-trunc(Random*100.0))*100.0)/100.0;
B=trunc((Random*10000.0-trunc(Random*10000.0))*100.0)/100.0;

rotate2d(s,t,radians(rot * i * urand()), 0.5*urand(), 0.5*urand(), ss, tt);
//layer_color = color(0,(i+1)/iteration,0);
layer_color = color((i+1)/iteration * urand(), G*0.5 , B*0.4);
layer_opac = pulse(0.50, 0.55, fuzz, tt);
surface_color = blend(surface_color, layer_color, layer_opac);
}

for (float i=0.0; i<iteration; i++){

// want random
float Random=0;
float R=0;
float G=0;
float B=0;
getattribute("object:random", Random);
R=trunc(Random*100.0)/100.0;
G=trunc((Random*100.0-trunc(Random*100.0))*100.0)/100.0;
B=trunc((Random*10000.0-trunc(Random*10000.0))*100.0)/100.0;

rotate2d(s,t,radians(rot * i * urand()), 0.5*urand(), 0.5*urand(), ss, tt);
//layer_color = color(0,(i+1)/iteration,0);
layer_color = color((i+1)/iteration * urand(), G*0.5 , B*0.4);
layer_opac = pulse(0.50, 0.55, fuzz, ss);
surface_color = blend(surface_color, layer_color, layer_opac);
}


/*
// horizontal bar layer
layer_color = color(0.1,0.1,0.3);
layer_opac = pulse(0.35, 0.65, fuzz, t);
surface_color = blend(surface_color, layer_color, layer_opac);
*/

// output if we need to specify CLOSURE

Oi = surface_opac;
// Ci = surface_opac * surface_color;
Col_Out = surface_opac * surface_color;

}

I want to show step by step process how I get to the current look of Wooly OSL Shader.

(TO BE ADDED)

BONUS: SPLINE FUNCTION

Spline function is like Color Ramp node in Cycles. Allowing us to have multiple color array to blend. Useful for things like FIRE.

color colorarray[X] = { .... }

spline("linear", colorarray ....

http://blenderartists.org/forum/showthread.php?274730-OSL-Porting-from-RSL

BONUS: PULSE FUNCTION

Pulse is like the combination of smoothstep...

Feel free to modify and mix the code above.

QUESTION ARISE...

If we compare the built-in Blender MIX Node that does blending with the function above, we can see that the result is a bit different sometimes. I am wondering why is that happening? Is it because things got "normalized" with the premade node and more correct?

I guess I need to compare the code from the book with what comes with Blender. Further investigation needed.

However, with the above code example, we start to think about LAYERING in OSL. OSL is certainly handy for:
- Procedural Pattern and Texture creation
- Texture Mapping
- Complex Blending
- Utility

I guess, the "best" of OSL is when shader writing is used together with the node network, so this is something we (more artists than coders) can always kept in mind.

REWRITING OSL CODE FOR LAYERING

Still reading this book, but I am most interested with Chapter 12 "Procedural Patterns".

Although some part is still quite complicated to understand, the book is quite consistent in term of explaining the concept of "LAYERING" and "PROCEDURAL PATTERN".

This one example is also translated from the book to OSL. It seems complex at a glance, but this is actually simple and it explains a lot of things. I like how the code is nicely organized and every functions are separated from the main Shader code:

Helper Function to Rotate Texture in 2D: rotate2d()
Few other helper functions: pulse(), repeat(), blend()
Concept of Layering and Opacity (Masking) using code.

CODE:

// converted from book Renderman Shading Language Guide
// page 370, for shader called "Optical Illussion"
// OSL code translation by Jimmy Gunawan

// the following HELPER FUNCTIONS was translated from 'rmannotes.sl'

float pulse (
float a,
float b,
float fuzz,
float x
)
{
return (smoothstep((a)-(fuzz), (a), (x)) - smoothstep((b)-(fuzz), (b), (x)));
}

float repeat(
float x,
float freq
)
{
return (mod((x) * (freq), 1.0));
}

/*
rotate2d is taken from rmannotes.sl
2D rotation of point(x,y) about origin(ox,oy) by and angle rad.
the resulting point is (rx, ry).

*/

void rotate2d (
float x,
float y,
float rad,
float ox,
float oy,
float rx,
float ry
)
{
rx = ((x) - (ox)) * cos(rad) - ((y) - (oy)) * sin(rad) + (ox);
ry = ((x) - (ox)) * sin(rad) + ((y) - (oy)) * cos(rad) + (oy);
}

color blend(
color a,
color b,
color x
)

{
return ((a) * (1-(x)) + (b) * (x));
}


shader optill(
float fuzziness = 0.025,
float freq = 10,
float thickness1 = 0.75,
float thickness2 = 0.75,
float rot = 45,
color baseColor = color(0,0,0),
color c1 = color(1,0,0),
color c2 = color(0,1,0),
vector Pos = P,
output color ColOut = color(1)
)
{
color surface_color;
color layer_color;

color surface_opac;
color layer_opac;

float fuzz = fuzziness;
float ss;
float tt;

surface_color = baseColor;
surface_opac = color(0);

// assign pixel position as s and t
float s = Pos[0];
float t = Pos[1];

// rotate stuff in 2D
rotate2d(s,t,radians(rot), 0.5, 0.5, ss, tt);

// repeat pattern
ss = repeat(ss, freq);
tt = repeat(tt, freq);

float pwh = thickness1 * 1.0/freq;
float pwv = thickness2 * 1.0/freq;

// This is Layer 1 covering Layer 0 (Base Layer)
layer_opac = pulse(0.5-pwh, 0.5+pwh, fuzz, ss);
surface_color = blend(surface_color, c1, layer_opac);

// This is Layer 2 covering Layer 1
layer_opac = pulse(0.5-pwv, 0.5+pwv, fuzz, tt);
surface_color = blend(surface_color, c2, layer_opac);

ColOut = surface_color;

// I omited some code in relation to "Opacity"
// because I am not quite sure how it works.
// However I will revise it in the future, hopefully!

}

The result of the above code can be seen as below.

We have 3 Layers (Color):
- Base
- c1
- c2

We can then try something like below:

We are using Image Textures and using the code above to layer them together:

Thing started to get more interesting, right? I thought so too.

Some parts may still be abstract, but when the code is arranged this way, we started to see something that looks like typical 2D Layerings in 2D image editing packages.

All contained within a single node, instead of complex noodles of node network.

The book is really teaching concept of:
- MULTI LAYER
- OPACITY or MASK
- BLEND as CODE

When thinking of Shader this way, whether we are using pre-made nodes, custom procedural textures, or image textures, or combinations of everything, thing is a lot more simple. We separate the problem in layers and then we will start LAYERING the COMPLEXITY, while still having enough CONTROL to achieve the look we like.

EXPLICIT vs IMPLICIT FUNCTIONS

At this moment, perhaps for me, the hardest part of the code is to think of Pattern Creation "IMPLICITELY", instead of "EXPLICITELY".

When doing coding to draw a shape in program like Processing, we can simply say things like:
ellipse(5,5,0,0);
// draw an ellipse shape of size of 5x5 pixel at position (0,0).
// http://processing.org/reference/ellipse_.html

That's above is actually a simple function that is using EXPLICIT FUNCTIONS.

However, when doing SHADER WRITING (like OSL, OpenGL, RSL), even to create a simple shape of ellipse, we need to think kind of inside out. We are using IMPLICIT FUNCTIONS.
http://www.sciencehq.com/mathematics/implicit-and-explicit-functions.html

Porting RSL Star to OSL Star

Below is my effort to port code of RSL Star into OSL.

I still skipped some of code that is relating to the Closure and focusing on the Texture only. But I added few things and modify the code slightly.

Maybe read this thread about Closure here:
http://www.elysiun.com/forum/showthread.php?291827-Creating-OSL-Closures

Currently, I am only curious about OSL and RSL and how the math function works to create Procedural Textures that is then passed on to the Closure.

// SOURCE http://www.renderman.org/RMR/Shaders/DPShaders/DPStar.sl
// Roughly Ported to OSL by Jimmy Gunawan @ Blender Sushi
// Dated 2013.08.05

shader DPStar(
//float Ka = 1;
//float Kd = 1;
int npoints = 5,
float sctr = 0.5,
float tctr = 0.5,
//float Cs = 0.1, // Cs is probably like original Diffuse Color
//color starcolor = color (1.0000,0.5161,0.0000),
color Color_A = color(1,0,0),
color Color_B = color(0,1,0),
float rmin = 0.07,
float rmax = 0.2,
point Vector = P, // added this so that Vector can be plugged
output color Col_Out = color(0.8)
)

{
float PI = M_PI;
//point Nf = normalize(faceforward(N, I));
//color Ct;
float ss;
float tt;
float angle;
float r;
float a;
float in_out;
float starangle = 2*PI/npoints;


point p0 = rmax * point(cos(0),sin(0),0);
point p1 = rmin * point(cos(starangle/2),sin(starangle/2),0);

point d0 = p1 - p0;
point d1;

float x = Vector[0];
float y = Vector[1];

ss = x - sctr;
tt = y - tctr; // s t become u v or X and Y
angle = atan2(ss, tt) + PI;
r = sqrt(ss*ss + tt*tt);
a = mod(angle, starangle)/starangle;

if (a >= 0.5)
a = 1 - a;

d1 = r * point(cos(a), sin(a),0) - p0;

//in_out = step(0, zcomp(d0^d1));

point FORCE = cross(d0,d1);

in_out = step(0, FORCE[2]);

Col_Out = mix(Color_A,Color_B,in_out);

//Col_Out = mix(Cs, starcolor, in_out);

/* diffuse ("matte") shading model */
//Oi = Os;
//Ci = Os * Ct * (Ka * ambient() + Kd * diffuse(Nf));
}

FUNCTION zcomp() and cross()

It takes me a while to figure out how to translate this RSL function below:
zcomp(d0^d1)

Into OSL function:
The Z values of cross(d0,d1) // Cross Product of Point Positions d0 and d1

Below references helps me figure this out:

1. Some great examples here:
http://blenderartists.org/forum/showthread.php?274730-OSL-Porting-from-RSL

2. Google Books preview of book titled "Texturing and Modeling: A Procedural Approach".
Would be nice to have this book on hand, but luckily there is Google Books. That paragraph below helps me understanding what is happening and find the OSL equivalent.

I think that book is available at University of Technology of Sydney (UTS).

I also figure out that if we want to define point in OSL, we have to use syntax like this:

point myPointPos = point(0.2, 0.5, 1.0)

HAPPY ACCIDENTS

During this porting, I actually made few accident or mistakes, but by making "errors" I figure out interesting results...

// SOURCE http://www.renderman.org/RMR/Shaders/DPShaders/DPStar.sl
// Roughly Ported to OSL by Jimmy Gunawan
// Dated 2013.08.05

shader DPStar(
//float Ka = 1;
//float Kd = 1;
int npoints = 5,
float sctr = 0.5,
float tctr = 0.5,
//float Cs = 0.1, // Cs is probably like original Diffuse Color
//color starcolor = color (1.0000,0.5161,0.0000),
color Color_A = color(1,0,0),
color Color_B = color(0,1,0),
float rmin = 0.07,
float rmax = 0.2,
point Vector = P, // added this so that Vector can be plugged
output color Col_Out = color(0.8)
)

{
float PI = M_PI;
//point Nf = normalize(faceforward(N, I));
//color Ct;
float ss;
float tt;
float angle;
float r;
float a;
float in_out;
float starangle = 2*PI/npoints;


point p0 = rmax * point(cos(0),sin(0),0);
point p1 = rmin * point(cos(starangle/2),sin(starangle/2),0);

point d0 = p1 - p0;
point d1;

float x = Vector[0];
float y = Vector[1];

ss = x - sctr;
tt = y - tctr; // s t become u v or X and Y
angle = atan2(ss, tt) + PI;
r = sqrt(ss*ss + tt*tt);
a = mod(angle, starangle)/starangle;

if (a >= 0.5)
a = 1 - a;

d1 = r * point(cos(a), sin(a),0) - p0;

//in_out = step(0, zcomp(d0^d1));

//point FORCE = cross(d0,d1);

in_out = step(0, d1[0]);

Col_Out = mix(Color_A,Color_B,in_out);

//Col_Out = mix(Cs, starcolor, in_out);

/* diffuse ("matte") shading model */
//Oi = Os;
//Ci = Os * Ct * (Ka * ambient() + Kd * diffuse(Nf));
}

// SOURCE http://www.renderman.org/RMR/Shaders/DPShaders/DPStar.sl
// Roughly Ported to OSL by Jimmy Gunawan
// Dated 2013.08.05

shader DPStar(
//float Ka = 1;
//float Kd = 1;
int npoints = 5,
float sctr = 0.5,
float tctr = 0.5,
//float Cs = 0.1, // Cs is probably like original Diffuse Color
//color starcolor = color (1.0000,0.5161,0.0000),
color Color_A = color(1,0,0),
color Color_B = color(0,1,0),
float rmin = 0.07,
float rmax = 0.2,
point Vector = P, // added this so that Vector can be plugged
output color Col_Out = color(0.8)
)

{
float PI = M_PI;
//point Nf = normalize(faceforward(N, I));
//color Ct;
float ss;
float tt;
float angle;
float r;
float a;
float in_out;
float starangle = 2*PI/npoints;


point p0 = rmax * point(cos(0),sin(0),0);
point p1 = rmin * point(cos(starangle/2),sin(starangle/2),0);

point d0 = p1 - p0;
point d1;

float x = Vector[0];
float y = Vector[1];

ss = x - sctr;
tt = y - tctr; // s t become u v or X and Y
angle = atan2(ss, tt) + PI;
r = sqrt(ss*ss + tt*tt);
a = mod(angle, starangle)/starangle;

if (a >= 0.5)
a = 1 - a;

d1 = r * point(cos(a), sin(a),0) - p0;

//in_out = step(0, zcomp(d0^d1));

//point FORCE = cross(d0,d1);

//in_out = step(0, a);

Col_Out = mix(Color_A,Color_B,a);

//Col_Out = mix(Cs, starcolor, in_out);

/* diffuse ("matte") shading model */
//Oi = Os;
//Ci = Os * Ct * (Ka * ambient() + Kd * diffuse(Nf));
}

// SOURCE http://www.renderman.org/RMR/Shaders/DPShaders/DPStar.sl
// Roughly Ported to OSL by Jimmy Gunawan
// Dated 2013.08.05

shader DPStar(
//float Ka = 1;
//float Kd = 1;
int npoints = 5,
float sctr = 0.5,
float tctr = 0.5,
//float Cs = 0.1, // Cs is probably like original Diffuse Color
//color starcolor = color (1.0000,0.5161,0.0000),
color Color_A = color(1,0,0),
color Color_B = color(0,1,0),
float rmin = 0.07,
float rmax = 0.2,
point Vector = P, // added this so that Vector can be plugged
output color Col_Out = color(0.8)
)

{
float PI = M_PI;
//point Nf = normalize(faceforward(N, I));
//color Ct;
float ss;
float tt;
float angle;
float r;
float a;
float in_out;
float starangle = 2*PI/npoints;

point p0 = rmax * point(cos(0),sin(0),0);
point p1 = rmin * point(cos(starangle/2),sin(starangle/2),0);

point d0 = p1 - p0;
point d1;

float x = Vector[0];
float y = Vector[1];

ss = x - sctr;
tt = y - tctr; // s t become u v or X and Y
angle = atan2(ss, tt) + PI;
r = sqrt(ss*ss + tt*tt);
a = mod(angle, starangle)/starangle;

//if (a >= 0.5)
// a = 1 - a;

d1 = r * point(cos(a), sin(a),0) - p0;

//in_out = step(0, zcomp(d0^d1));

//point FORCE = cross(d0,d1);

//in_out = step(0, a);

Col_Out = mix(Color_A,Color_B,a);

//Col_Out = mix(Cs, starcolor, in_out);

/* diffuse ("matte") shading model */
//Oi = Os;
//Ci = Os * Ct * (Ka * ambient() + Kd * diffuse(Nf));
}

// SOURCE http://www.renderman.org/RMR/Shaders/DPShaders/DPStar.sl
// Roughly Ported to OSL by Jimmy Gunawan
// Dated 2013.08.05

shader DPStar(
//float Ka = 1;
//float Kd = 1;
int npoints = 5,
float sctr = 0.5,
float tctr = 0.5,
//float Cs = 0.1, // Cs is probably like original Diffuse Color
//color starcolor = color (1.0000,0.5161,0.0000),
color Color_A = color(1,0,0),
color Color_B = color(0,1,0),
float rmin = 0.07,
float rmax = 0.2,
point Vector = P, // added this so that Vector can be plugged
output color Col_Out = color(0.8)
)

{
float PI = M_PI;
//point Nf = normalize(faceforward(N, I));
//color Ct;
float ss;
float tt;
float angle;
float r;
float a;
float in_out;
float starangle = 2*PI/npoints;


point p0 = rmax * point(cos(0),sin(0),0);
point p1 = rmin * point(cos(starangle/2),sin(starangle/2),0);

point d0 = p1 - p0;
point d1;

float x = Vector[0];
float y = Vector[1];

ss = x - sctr;
tt = y - tctr; // s t become u v or X and Y
angle = atan2(ss, tt) + PI;
r = sqrt(ss*ss + tt*tt);
a = mod(angle, starangle)/starangle;

if (a >= 0.5)
a = 1 - a;

d1 = r * point(cos(a), sin(a),0) - p0;

//in_out = step(0, zcomp(d0^d1));

point FORCE = cross(d0,d1);


in_out = step(0, FORCE[2]);

Col_Out = mix(Color_A,Color_B,d1[0]);

//Col_Out = mix(Cs, starcolor, in_out);

/* diffuse ("matte") shading model */
//Oi = Os;
//Ci = Os * Ct * (Ka * ambient() + Kd * diffuse(Nf));
}

There must be some clever Math in there that should be explained. I shall contact one of my friend who is a Math guru to explain what is happening. Anyway, as a visual person, I am quite happy to see something already happening.

The important thing, I think, as CG Artist, who likes to use this OSL capability is to understand what is going on. There are already some examples of procedural RSL Texture that can potentially be ported to OSL. Eventually they are all will be available for us to use, I guess.

So, the next step for Artists is to MIX and MATCH and LAYER the code to create a complete and more complex shader.

For this simple Star OSL shader alone, I made nearly a hundred of mistakes (OSL compile errors), but I think it is worth it and hopefully can contribute a little for the OSL community.

I checked the errors and see what lines is causing the error, and comment out parts and do some tests, repeating this process, I finally got this final OSL Star right!

SOMETIMES I FEEL LIKE A NEWBIE...

The OSL Star has basic star variables: Number of Star, Inner Radius, Outer Radius, X and Y Offset Position.

It may seem silly to feel excited being able to create simple primitive procedural DOT, LINE, CIRCLE, RING, STRIPES, and ... STAR, when we saw hundred of posts already taking OSL to "high level":
http://www.blenderartists.org/forum/showthread.php?270332-OSL-Goodness

However, I believe that I need to write things like this and will worth it. I hope that some of you feel the same too and contribute little by little.

So, indeed writing Shader is a little bit like "drawing blind".

QUESTIONS ARISE...

It is nice that we can now create procedural Dragon Ball Texture... :)

... however, more questions arise:

The shader seems to be always projected to the Front and Back Surface, how do we limit or make it to show up only on Front Facing Face? Maybe something to do with N (normal) of Surface?
How to REPEAT and TILE Texture? --- this question keeps popping up and I am not getting answer... I started to see how the U and V can be replaced with P position X and Y, but tiling... is tricky, unless someone can explain. DingTo, if you read this... please help.
READING MATERIAL:
http://blenderartists.org/forum/archive/index.php/t-277284.html
How do we LAYER Texture Procedurally using OSL and how to do layering using Cycles node network?
READING MATERIAL:
http://blenderartists.org/forum/archive/index.php/t-293132.html
http://vadrouillegraphique.blogspot.fr/2013/05/pyla-physically-correct-layer-shader.html
What is a function that adds STROKE? If I want stroke on the star procedurally, for example...
Can we repeat the Stars IN and OUT?
What Math equation to use to ROTATE the Star? ANSWERED 2013.08.06.
Can we create FLOWER instead of STAR?
Can we actually use RANDOM and SCATTER efficiently for OSL?
Can we turn STAR shader into SPIDERWEB, BICYCLE WHEEL WIRES, etc...

Will update them when answered.

...QUESTIONS ANSWERED!

Update 2013.08.06:

ROTATE THE STAR

Thanks to Gottfried at BlenderDiplom for his Twitter reply and the answer lies here on his blog:

http://cgcookie.com/blender/lessons/introduction-to-osl-in-blender-cycles-part-02/

I must have missed that info last time. I cleaned up the code a bit and highlight the changes in BOLD.

Adding just few lines and variable to the code allowing for rotation of the Star:

// SOURCE http://www.renderman.org/RMR/Shaders/DPShaders/DPStar.sl

// Roughly Ported to OSL by Jimmy Gunawan

// Dated 2013.08.06

shader BSStar(

int npoints = 5,

float sctr = 0.5,

float tctr = 0.5,

color Color_A = color(1,0,0),

color Color_B = color(0,1,0),

float rmin = 0.07,

float rmax = 0.2,

float RotAngle = 0.0,

point Vector = P,

output color Col_Out = color(0.8)

)

{

float PI = M_PI;

float ss;

float tt;

float angle;

float r;

float a;

float in_out;

float starangle = 2*PI/npoints;

point p0 = rmax * point(cos(0),sin(0),0);

point p1 = rmin * point(cos(starangle/2),sin(starangle/2),0);

point d0 = p1 - p0;

point d1;

float x = Vector[0];

float y = Vector[1];

ss = x - sctr;

tt = y - tctr; // s t become u v or X and Y

angle = atan2(ss, tt) + PI/180 * -RotAngle;

r = sqrt(ss*ss + tt*tt);

a = mod(angle, starangle)/starangle;

if (a >= 0.5)

a = 1 - a;

d1 = r * point(cos(a), sin(a),0) - p0;

point ZCOMPONENT = cross(d0,d1);

in_out = step(0, ZCOMPONENT[2]);

Col_Out = mix(Color_A,Color_B,in_out);

}

PI / 180 is so that the value goes slower when rotation. Converting Radian to Degree, I think.
I also put MINUS on the RotAngle, so that the rotation is Clockwise when number is increased, it is more logical.
angle = atan2(ss, tt) + PI/180 * RotAngle;
angle = atan2(ss, tt) + PI/180 * -RotAngle; //same thing
angle = atan2(ss, tt) - PI/180 * RotAngle; // same thing

Thanks Goffried, now the Star is rotate-able and animate-able.

Adding lines by lines and understanding the OSL code is a good way to properly code a shader.

There are already clever Math people out there creating bunch of useful functions, all we need to do is to use and implement them. Sometimes, we really don't always need to understand the whole function and codes, just understanding what it does to allow us to modify them to suit our need.

REPEATING THE STARS

Updated 2013.08.07 after I read this document properly:

http://nccastaff.bournemouth.ac.uk/jmacey/Renderman/slides/RendermanShaders1.pdf

float ss = mod(sRepeatS,1);
float tt = mod(tRepeatT,1);

// SOURCE http://www.renderman.org/RMR/Shaders/DPShaders/DPStar.sl
// Roughly Ported to OSL by Jimmy Gunawan
// Dated 2013.08.07

shader BSStar(
int npoints = 5,
float sctr = 0.5,
float tctr = 0.5,
color Color_A = color(1,0,0),
color Color_B = color(0,1,0),
float rmin = 0.07,
float rmax = 0.2,
float RotAngle = 0.0,
point Vector = P,
float RepeatS = 4.0,
float RepeatT = 4.0,
output color Col_Out = color(0.8)
)

{
float PI = M_PI;
float ss;
float tt;
float angle;
float r;
float a;
float in_out;
float starangle = 2*PI/npoints;


point p0 = rmax * point(cos(0),sin(0),0);
point p1 = rmin * point(cos(starangle/2),sin(starangle/2),0);

point d0 = p1 - p0;
point d1;

float x = Vector[0];
float y = Vector[1];

ss = mod(x * RepeatS, 1) - sctr;
tt = mod(y * RepeatT, 1) - tctr; // s t become u v or X and Y
angle = atan2(ss, tt) + PI/180 * -RotAngle;
r = sqrt(ss*ss + tt*tt);
a = mod(angle, starangle)/starangle;

if (a >= 0.5)
a = 1 - a;

d1 = r * point(cos(a), sin(a),0) - p0;

point ZCOMPONENT = cross(d0,d1);

in_out = step(0, ZCOMPONENT[2]);

Col_Out = mix(Color_A,Color_B,in_out);

}

OSL CLOVER / FLOWER

I need a bit more time to study this one and make sense of it, but probably you can also do study on it.
http://blenderartists.org/forum/showthread.php?277334-Flowers-OSL
http://www.youtube.com/watch?feature=player_embedded&v=-z8zLVFCJv4

MORE REFERENCES:

http://www.renderman.org/RMR/RMRShaders.html
http://www.renderman.org/RMR/Shaders/DPShaders/index.html
http://web.engr.oregonstate.edu/~mjb/prman/shaderfunctions.html

Labels

Movies Post

Sports

Music

Business

Pictures

728x90 AdSpace

Travel

Fashion

Design

Movies

Recent Videos

Labels

Category

Slider

Recent Post

Games

Popular Posts

Pages

Find Us On Facebook

Links

About Me

Technology

Breaking News