mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-28 01:32:14 +03:00
[osl/en] Added OSL and covered almost everything (#4857)
* added OSL language Added most of the basics * Update osl.html.markdown * Updated Datatypes * Added some functions * Update osl.html.markdown * Added Pattern Generations, Calculus, Texture and Light functions * Final * fixed 80 words * Added Examples
This commit is contained in:
Preetham Pemmasani
GitHub
parent
d72ab67435
commit
4273e67f56
751
osl.html.markdown
Normal file
751
osl.html.markdown
Normal file
@ -0,0 +1,751 @@
|
||||
---
|
||||
language: osl
|
||||
filename: learnosl.osl
|
||||
contributors:
|
||||
- ["Preetham Pemmasani", "https://github.com/Preetham-ai"]
|
||||
---
|
||||
|
||||
OSL (Open Shading Language) is a programming language designed by Sony for Arnold Renderer used for creating shaders.
|
||||
|
||||
[Read more here.](https://raw.githubusercontent.com/imageworks/OpenShadingLanguage/master/src/doc/osl-languagespec.pdf)
|
||||
|
||||
```c
|
||||
|
||||
|
||||
// Single-line comments start with //
|
||||
|
||||
/* Multi line comments are preserved. */
|
||||
|
||||
// Statements can be terminated by ;
|
||||
divide(1,2);
|
||||
|
||||
///////////////
|
||||
// 1. Basics //
|
||||
///////////////
|
||||
|
||||
// Declating variables
|
||||
color Blue; // Initializing a variable
|
||||
int _num = 3;
|
||||
float Num = 3.00;
|
||||
float c[3] = {0.1, 0.2, 3.14}; // Array
|
||||
|
||||
// Math works as you would expect
|
||||
3 + 1; // 4
|
||||
74 - 3; // 71
|
||||
20 * 2; // 40
|
||||
75/3; // 25.0
|
||||
|
||||
// And modulo division only works with integers
|
||||
10 % 2; // 0
|
||||
31 % 4; // 1
|
||||
|
||||
// Bitwise operations only works with integers
|
||||
- 0 // 1 (Unary Negation)
|
||||
~ 00100011 // 11011100 (bitwise Compliment)
|
||||
1 << 2; // 4 (shift Left)
|
||||
12 >> 1; // 3 (shift Right)
|
||||
1 & 0; // 0 (bitwise AND)
|
||||
1 | 0; // 1 (bitwise OR)
|
||||
1 ^ 1; // 0 (bitwise XOR)
|
||||
|
||||
// We also have booleans
|
||||
true;
|
||||
false;
|
||||
|
||||
// Booleans can't be compared to integers
|
||||
true == 1 // Error
|
||||
false == 0 // Error
|
||||
|
||||
// Negation uses the ! symbol
|
||||
!0; // 1
|
||||
!1; // 0
|
||||
!2; // 0
|
||||
//... and so on
|
||||
|
||||
// Relation Operators are defined like:
|
||||
0 == 0 // true (equal to)
|
||||
0 != 1 // true (not equal to)
|
||||
5 < 3 // false (less then)
|
||||
3 <= 3 // true (less than or equal to)
|
||||
69 > 69 // false (greater than)
|
||||
99 >= 52 // true (greater than or equal)
|
||||
|
||||
|
||||
// Functions are same as C and C++
|
||||
float sum(float a, float b){
|
||||
return a+b;
|
||||
}
|
||||
|
||||
int subtract(int a, int b){
|
||||
return a-b;
|
||||
}
|
||||
|
||||
sum(2,3); // 5
|
||||
|
||||
////////////////
|
||||
// 2. Shaders //
|
||||
////////////////
|
||||
|
||||
// Shaders explain the custom behavior of materials and light
|
||||
// Shader's syntax is similar to the main function in C
|
||||
// The inputs and the outputs should be initialized to default types
|
||||
shader multiply(float a = 0.0,
|
||||
float b = 0.0,
|
||||
output float c = 0.0){
|
||||
c = a*b;
|
||||
}
|
||||
|
||||
// Double brackets[[ ]] is used to classify metadata of a shader
|
||||
surface plastic
|
||||
[[ string help = "Realistic wood shader" ]]
|
||||
(
|
||||
color Plastic = color (0.7, 0.5, 0.3) [[ string help = "Base color" ]],
|
||||
float Reflectivity = 0.5 [[ float min = 0, float max = 1 ]],
|
||||
){...}
|
||||
|
||||
///////////////////////////////////////
|
||||
// Metadata Types
|
||||
///////////////////////////////////////
|
||||
|
||||
[[ string label = "IOR" ]] // Display-name in UI of the parameter
|
||||
[[ string help = "Change Refractive Index" ]] // Info about the parameter
|
||||
[[ string help = "widget" // Gives widgets to input the parameter
|
||||
string widget = "number" ]] // input float or int
|
||||
string widget = "string" ]] // String input
|
||||
string widget = "boolean" ]] // yes/no (or) 1/0
|
||||
string widget = "popup", options = "smooth|rough" ]] // Drop-down list
|
||||
// enum Drop-down list can also be made
|
||||
string widget = "mapper", options = "smooth:0|rough:1" ]]
|
||||
string widget = "filename" ]] // Input files externally
|
||||
string widget = "null" ]] // null input
|
||||
|
||||
[[ float min = 0.0 ]] // Minimum value of parameter
|
||||
[[ float max = 0.5 ]] // Maximum value of parameter
|
||||
[[ int slider = 3.0 // Adds a slider as an input
|
||||
int slidermin = -1]] // minimum value of the slider
|
||||
int slidermax = 3]] // maximum value of the slider
|
||||
int slidercenter = 2]] // origin value of the slider
|
||||
|
||||
[[ float sensitivity = 0.5 ]] // step size for incrementing the parameter
|
||||
[[ string URL = www.example.com/ ]] // URL of shader's documentation
|
||||
|
||||
|
||||
|
||||
// There are different types of shaders
|
||||
|
||||
/* Surface shaders determine the basic material properties of a surface and
|
||||
how it reacts to light */
|
||||
// Light shaders are a type of SURFACE shaders used for emissive objects.
|
||||
// Displacement shaders alter the geometry using position and normals.
|
||||
// Volume shaders adds a medium like air/smoke/dust into the scene.
|
||||
|
||||
volume multiply(float a = 0.0, float b = 0.0, output float c = 0.0){
|
||||
c = 2*a+b;
|
||||
}
|
||||
|
||||
////////////////////////////////////////
|
||||
// 3. Data Types and Global Variables //
|
||||
////////////////////////////////////////
|
||||
|
||||
// Data Types
|
||||
|
||||
// 1. The void type indicates a function that doesn't return any value
|
||||
|
||||
// 2. int (Integer)
|
||||
int x = -12; // Minimum size of 32-bits
|
||||
int new2 = 0x01cf; // Hexadecimal can also be specified
|
||||
|
||||
///////////////////////////////////////
|
||||
// Order of Evaluation
|
||||
///////////////////////////////////////
|
||||
|
||||
// From top to bottom, top has higher precedence
|
||||
//--------------------------//
|
||||
// Operators //
|
||||
//--------------------------//
|
||||
// int++, int-- //
|
||||
// ++ int --int - ~ ! //
|
||||
// * / % //
|
||||
// + - //
|
||||
// << >> //
|
||||
// < <= > >= //
|
||||
// == != //
|
||||
// & //
|
||||
// ^ //
|
||||
// | //
|
||||
// && //
|
||||
// || //
|
||||
// ?: //
|
||||
// = += -= *= /= //
|
||||
//--------------------------//
|
||||
|
||||
// 3. float (Floating-point number)
|
||||
float A = 2.3; // minimum IEEE 32-bit float
|
||||
float Z = -4.1e2; // Z = -4.1 * 10^2
|
||||
|
||||
// Order of evaluation is similar to int.
|
||||
// Operations like ( ~ ! % << >> ^ | & && || ) aren't available in float
|
||||
|
||||
// 4. string
|
||||
// The syntax is similar to C
|
||||
string new = "Hello World";
|
||||
// some Special characters:
|
||||
/*
|
||||
'\"'; // double quote
|
||||
'\n'; // newline character
|
||||
'\t'; // tab character (left justifies text)
|
||||
'\v'; // vertical tab
|
||||
'\\'; // back slash
|
||||
'\r'; // carriage return
|
||||
'\b'; // backspace character
|
||||
*/
|
||||
|
||||
// Strings are concatenated with whitespace
|
||||
"Hello " "world!"; // "Hello world!"
|
||||
// concat function can also be used
|
||||
string concat ("Hello ","World!"); // "Hello world!"
|
||||
|
||||
// printf function is same as C
|
||||
int i = 18;
|
||||
printf("I am %d years old",i); // I am 18 years old
|
||||
|
||||
// String functions can alse be used
|
||||
int strlen (string s); // gives the length of the string
|
||||
int len = strlen("Hello, World!"); // len = 13
|
||||
|
||||
// startswith returns 1 if string starts with prefix, else returns 0
|
||||
int starts = startswith("The quick brown fox", "The"); // starts = 1
|
||||
|
||||
// endswith returns 1 if string starts with suffix, else returns 0
|
||||
int ends = endswith("The quick brown fox", "fox"); // ends will be 1
|
||||
|
||||
// 5. color (Red, Green, Blue)
|
||||
color p = color(0,1,2); // black
|
||||
color q = color(1); // white ( same as color(1,1,1) )
|
||||
color r = color("rgb", 0.23, 0.1, 0.8); // explicitly specify in RGB
|
||||
color s = color("hsv", 0.23, 0.1, 0.8); // specify in HSV
|
||||
// HSV stands for (Hue, Saturation, Luminance)
|
||||
// HSL stands for (Hue, Saturation, Lightness)
|
||||
// YIQ, XYZ and xyY formats can also be used
|
||||
// We can also access the indivudual values of (R,G,B)
|
||||
float Red = p[0]; // 0 (access the red component)
|
||||
float Green = p[1]; // 1 (access the green component)
|
||||
float Blue = p[2]; // 2 (access the blue component)
|
||||
|
||||
// They can also be accessed like this
|
||||
float Red = p.r; // 0 (access the red component)
|
||||
float Green = p.g; // 1 (access the green component)
|
||||
float Blue = p.b; // 2 (access the blue component)
|
||||
|
||||
// Math operators work like this with decreasing precedence
|
||||
color C = (3,2,3) * (1,0,0); // (3, 0, 0)
|
||||
color D = (1,1,1) * 255; // (255, 255, 255)
|
||||
color E = (25,5,125) / 5; // (5, 1, 25)
|
||||
color F = (30,40,50) / (3,4,5); // (10, 10, 10)
|
||||
color A = (1,2,3) + (1,0,0); // (2, 2, 3)
|
||||
color B = (1,2,3) - (1,0,0); // (0, 2, 3)
|
||||
// Operators like ( - == != ) are also used
|
||||
|
||||
// Color Functions
|
||||
color blackbody (1500) // Gives color based on temperature (in Kelvin)
|
||||
float luminance (0.5, 0.3, 0.8) // 0.37 gives luminance cd/m^2
|
||||
// Luminance is calculated by 0.2126R+0.7152G+0.0722B
|
||||
color wavelength color (700) // (1, 0, 0) Gives color based on wavelength
|
||||
color transformc ("hsl", "rgb") // converts one system to another
|
||||
|
||||
// 6. point (x,y,z) is position of a point in the 3D space
|
||||
// 7. vector (x,y,z) has length and direction but no position
|
||||
// 8. normal (x,y,z) is a special vector perpendicular to a surface
|
||||
// These Operators are the same as color and have the same precedence
|
||||
L = point(0.5, 0.6, 0.7);
|
||||
M = vector(30, 100, 70);
|
||||
N = normal(0, 0, 1);
|
||||
|
||||
// These 3 types can be assigned to a coordinate system
|
||||
L = point("object", 0.5, 0.6, 0.7); // relative to local space
|
||||
M = vector("common", 30, 100, 70); // relative to world space
|
||||
// There's also ("shader", "world", "camera", "screen", "raster", "NDC")
|
||||
|
||||
float x = L[0]; // 0.5 (access the x-component)
|
||||
float y = L[1]; // 0.6 (access the y-component)
|
||||
float z = L[2]; // 0.7 (access the z-component)
|
||||
|
||||
// They can also be accessed like this
|
||||
float x = M.x; // 30 (access the x-component)
|
||||
float y = M.y; // 100 (access the y-component)
|
||||
float z = M.z; // 70 (access the z-component)
|
||||
|
||||
float a = dot ((1,2,3), (1,2,3)); // 14 (Dot Product)
|
||||
vector b = cross ((1,2,3), (1,2,3)); // (0,0,0) (Cross Product)
|
||||
float l = length(L); // 1.085 (length of vector)
|
||||
vector normalize (vector L); // (0.460, 0.552, 0.644) Normalizes the vector
|
||||
|
||||
point p0 = point(1, 2, 3);
|
||||
point p1 = point(4, 5, 6);
|
||||
point Q = point(0, 0, 0);
|
||||
|
||||
// Finding distance between two points
|
||||
float len = distance(point(1, 2, 3), point(4, 5, 6)); // 5.196
|
||||
// Perpendicular distance from Q to line joining P0 and P1
|
||||
float distance (point P0, point P1, point Q); // 2.45
|
||||
|
||||
|
||||
// 9. matrix
|
||||
// Used for transforming vectors between different coordinate systems.
|
||||
// They are usually 4x4 (or) 16 floats
|
||||
matrix zero = 0; // makes a 4x4 zero matrix
|
||||
/* 0.0, 0.0, 0.0, 0.0,
|
||||
0.0, 0.0, 0.0, 0.0,
|
||||
0.0, 0.0, 0.0, 0.0,
|
||||
0.0, 0.0, 0.0, 0.0 */
|
||||
|
||||
matrix ident = 1; // makes a 4x4 identity matrix
|
||||
/* 1.0, 0.0, 0.0, 0.0,
|
||||
0.0, 1.0, 0.0, 0.0,
|
||||
0.0, 0.0, 1.0, 0.0,
|
||||
0.0, 0.0, 0.0, 1.0 */
|
||||
|
||||
matrix m = 7; // Maked a 4x4 scalar matrix with scaling factor of 7
|
||||
/* 7.0, 0.0, 0.0, 0.0,
|
||||
0.0, 7.0, 0.0, 0.0,
|
||||
0.0, 0.0, 7.0, 0.0,
|
||||
0.0, 0.0, 0.0, 7.0 */
|
||||
|
||||
float x = m[1][1]; // 7
|
||||
|
||||
// matrices can be constructed using floats in row-major order
|
||||
// matrices are usually 4x4 with 16 elements
|
||||
matrix myMatrix = matrix(1.0, 0.0, 0.0, 0.0, // Row 1
|
||||
0.0, 2.0, 0.0, 0.0, // Row 2
|
||||
0.0, 0.0, 3.0, 0.0, // Row 3
|
||||
0.0, 0.0, 0.0, 4.0); // Row 4
|
||||
|
||||
// matrix transformations are easy to implement
|
||||
matrix a = matrix ("shader", 1); // converted shader to common
|
||||
matrix m = matrix ("object", "world"); // converted object to world
|
||||
|
||||
// Operations that can be used with decreasing precedence are:
|
||||
// ( - * / == !=)
|
||||
|
||||
float determinant (matrix M) // 24 (returns the determinant of the matrix)
|
||||
float transpose (matrix M) // returns the transpose of the matrix
|
||||
/* 1.0, 0.0, 0.0, 0.0,
|
||||
0.0, 2.0, 0.0, 0.0,
|
||||
0.0, 0.0, 3.0, 0.0,
|
||||
0.0, 0.0, 0.0, 4.0 */
|
||||
|
||||
// 10. array
|
||||
// Arrays in OSL are similar to C
|
||||
float a[5]; // initialize array a with size 5
|
||||
int b[3] = {90,80,70}; // declare array with size 3
|
||||
int len = arraylength(b); // 3
|
||||
int f = b[1]; // 80
|
||||
float anotherarray[3] = b; // arrays can be copied if same type
|
||||
|
||||
// 11. struct (Structures)
|
||||
// Structures in OSL are similar to C and C++.
|
||||
struct RGBA { // Defining a structure
|
||||
color rgb;
|
||||
float alpha;
|
||||
};
|
||||
|
||||
|
||||
RGBA col; // Declaring a structure
|
||||
RGBA b = { color(0.1, 0.2, 0.3), 1 }; // Can also be declared like this
|
||||
|
||||
r.rgb = color (1, 0, 0); // Assign to one field
|
||||
color c = r.rgb; // Read from a structure field
|
||||
|
||||
// 12. closure
|
||||
// Closure is used to store data that aren't considered when it executes.
|
||||
// It cannot be manipulated or read.
|
||||
// A null closure can always be assigned.
|
||||
// OSL currently only supports color as their closure.
|
||||
|
||||
// A few examples of closures are:
|
||||
|
||||
// Diffuse BSDF closures:
|
||||
closure color oren_nayar_diffuse_bsdf(normal N, color alb, float roughness)
|
||||
closure color burley_diffuse_bsdf(normal N, color alb, float roughness);
|
||||
|
||||
// Dielectric BSDF closure:
|
||||
closure color dielectric_bsdf(normal N, vector U, color reflection_tint,
|
||||
color transmission_tint, float roughness_x, float roughness_y,
|
||||
float ior, string distribution);
|
||||
|
||||
// Conductor BSDF closure:
|
||||
closure color conductor_bsdf(normal N, vector U, float roughness_x,
|
||||
float roughness_y, color ior, color extinction, string distribution);
|
||||
|
||||
// Generalized Schlick BSDF closure:
|
||||
closure color generalized_schlick_bsdf(normal N, vector U,
|
||||
color reflection_tint, color transmission_tint,
|
||||
float roughness_x, float roughness_y, color f0, color f90,
|
||||
float exponent, string distribution);
|
||||
|
||||
// Translucent BSDF closure:
|
||||
closure color translucent_bsdf(normal N, color albedo);
|
||||
|
||||
// Transparent BSDF closure:
|
||||
closure color transparent_bsdf();
|
||||
|
||||
// Subsurface BSSRDF closure:
|
||||
closure color subsurface_bssrdf();
|
||||
|
||||
// Sheen BSDF closure:
|
||||
closure color sheen_bsdf(normal N, color albedo, float roughness);
|
||||
|
||||
// Anisotropic VDF closure: (Volumetric)
|
||||
closure color anisotropic_vdf(color albedo, color extinction,
|
||||
float anisotropy);
|
||||
|
||||
// Medium VDF closure: (Volumetric)
|
||||
closure color medium_vdf(color albedo, float transmission_depth,
|
||||
color transmission_color, float anisotropy, float ior, int priority);
|
||||
|
||||
closure color uniform edf(color emittance); // Emission closure
|
||||
closure color holdout(); // Holdout Hides objects beneath it
|
||||
|
||||
// BSDFs can be layered using this closure
|
||||
closure color layer (closure color top, closure color base);
|
||||
|
||||
|
||||
|
||||
// Global Variables
|
||||
// Contains info that the renderer knows
|
||||
// These variables need not be declared
|
||||
|
||||
point P // Position of the point you are shading
|
||||
vector I // Incident ray direction from viewing position to shading position
|
||||
normal N // Normal of the surface at P
|
||||
normal Ng // Normal of the surface at P irrespective of bump mapping
|
||||
float u // UV 2D x - parametric coordinate of geometry
|
||||
float v // UV 2D y - parametric coordinate of geometry
|
||||
vector dPdu // change of P with respect to u tangent to the surface
|
||||
vector dPdv // change of P with respect to v tangent to the surface
|
||||
float time // Current time
|
||||
float dtime // Time covered
|
||||
vector dPdtime // change of P with respect to time
|
||||
|
||||
/////////////////////
|
||||
// 4. Control flow //
|
||||
/////////////////////
|
||||
|
||||
// Conditionals in OSL are just like in C or C++.
|
||||
|
||||
// If/Else
|
||||
if (5>2){
|
||||
int x = s;
|
||||
int l = x;
|
||||
}
|
||||
else{
|
||||
int x = s + l;
|
||||
}
|
||||
|
||||
// 'while' loop
|
||||
int i = 0;
|
||||
while (i < 5) {
|
||||
i += 1;
|
||||
printf("Current value of i: %d\n", i);
|
||||
}
|
||||
|
||||
// 'do-while' loop is where test happens after the body of the loop
|
||||
int i = 0;
|
||||
do {
|
||||
printf("Current value of i: %d\n", i);
|
||||
i += 1;
|
||||
} while (i < 5);
|
||||
|
||||
// 'for' loop
|
||||
for (int i = 0; i < 5; i += 1) {
|
||||
printf("Current value of i: %d\n", i);
|
||||
}
|
||||
|
||||
/////////////////////
|
||||
// 5. Functions //
|
||||
/////////////////////
|
||||
|
||||
// Math Constants
|
||||
M_PI // π
|
||||
M_PI_35 // π/35
|
||||
m_E // e
|
||||
M_LN2 // ln 2
|
||||
M_SQRT2 // √2
|
||||
M_SQRT1_2 // √(1/2)
|
||||
|
||||
// Geometry Functions
|
||||
vector N = vector(0.1, 1, 0.2); // Normal vector
|
||||
vector I = vector(-0.5, 0.2, 0.8); // Incident vector
|
||||
|
||||
// Faceforward tells the direction of vector
|
||||
vector facing_dir = faceforward(N, I); // facing_dir = (-0.5, 0.2, 0.8)
|
||||
|
||||
// faceforward with three arguments
|
||||
vector ref = vector(0.3, -0.7, 0.6); // Reference normal
|
||||
facing_dir = faceforward(N, I, ref); // facing_dir = (0.5, -0.2, -0.8)
|
||||
|
||||
// reflect gives the reflected vector along normal
|
||||
vector refl = reflect(I, N); // refl = (-0.7, -0.4, 1.4)\
|
||||
|
||||
// refract gives the refracted vector along normal
|
||||
float ior = 1.5; // Index of refraction
|
||||
vector refr = refract(I, N, ior); // refr = (-0.25861, 0.32814, 0.96143)
|
||||
|
||||
/* Fresnel computes the Reflection (R) and Transmission (T) vectors, along
|
||||
with the scaling factors for reflected (Kr) and transmitted (Kt) light. */
|
||||
float Kr, Kt;
|
||||
vector R, T;
|
||||
fresnel(I, N, ior, Kr, Kt, R, T);
|
||||
/* Kr = 0.03958, Kt = 0.96042
|
||||
R = (-0.19278, -0.07711, 0.33854)
|
||||
T = (-0.25861, 0.32814, 0.96143) */
|
||||
|
||||
// Rotating a point along a given axis
|
||||
point Q = point(1, 0, 0);
|
||||
float angle = radians(90); // 90 degrees
|
||||
vector axis = vector(0, 0, 1);
|
||||
point rotated_point = rotate(Q, angle, axis);
|
||||
// rotated_point = point(0, 1, 0)
|
||||
|
||||
// Rotating a point along a line made by 2 points
|
||||
point P0 = point(0, 0, 0);
|
||||
point P1 = point(1, 1, 0);
|
||||
angle = radians(45); // 45 degrees
|
||||
Q = point(1, 0, 0);
|
||||
rotated_point = rotate(Q, angle, P0, P1);
|
||||
// rotated_point = point(0.707107, 0.707107, 0)
|
||||
|
||||
// Calculating normal of surface at point p
|
||||
point p1 = point(1, 0, 0); // Point on the sphere of radius 1
|
||||
vector normal1 = calculatenormal(p1);
|
||||
// normal1 = vector(1, 0, 0)
|
||||
|
||||
// Transforming units is easy
|
||||
float transformu ("cm", float x) // converts to cm
|
||||
float transformu ("cm", "m", float y) // converts cm to m
|
||||
|
||||
// Displacement Functions
|
||||
void displace (float 5); // Displace by 5 amp units
|
||||
void bump (float 10); // Bump by 10 amp units
|
||||
|
||||
|
||||
// Noise Generation
|
||||
|
||||
type noise (type noise (string noisetype, float u, float v, ...)); // noise
|
||||
type noise (string noisetype, point p,...); // point instead of coordinates
|
||||
/* some noises are ("perlin", "snoise", "uperlin", "noise", "cell", "hash"
|
||||
"simplex", "usimplex", "gabor", etc) */
|
||||
|
||||
// Noise Names
|
||||
|
||||
// 1. Perlin Noise (perlin, snoise):
|
||||
// Creates smooth, swirling noise often used for textures.
|
||||
// Range: [-1, 1] (signed)
|
||||
color cloud_texture = noise("perlin", P);
|
||||
|
||||
// 2. Simplex Noise (simplex, usimplex):
|
||||
// Similar to Perlin noise but faster.
|
||||
// Range: [-1, 1] (signed) for simplex, [0, 1] (unsigned) for usimplex
|
||||
float bump_amount = 0.2 * noise("simplex", P * 5.0);
|
||||
|
||||
// 3. UPerlin Noise (uperlin, noise):
|
||||
// Similar to peril
|
||||
// Range: [0, 1] (unsigned)
|
||||
color new_texture = noise("uperlin", P);
|
||||
|
||||
// 4. Cell Noise (cell):
|
||||
// Creates a blocky, cellular and constant values within each unit block
|
||||
// Range: [0, 1] (unsigned)
|
||||
color new_texture = noise("cell", P);
|
||||
|
||||
// 5. Hash Noise (hash):
|
||||
// Generates random, uncorrelated values at each point.
|
||||
// Range: [0, 1] (unsigned)
|
||||
color new_texture = noise("hash", P);
|
||||
|
||||
// Gabor Noise (gabor)
|
||||
// Gabor Noise is advanced version of Perin noies and gives more control
|
||||
// Range: [-1, 1] (signed)
|
||||
// Gabor Noise Parameters
|
||||
|
||||
// Anisotropic (default: 0)
|
||||
// Controls anisotropy:
|
||||
// 0: Isotropic (equal frequency in all directions)
|
||||
// 1: Anisotropic with user-defined direction vector (defaults to (1,0,0))
|
||||
/* 2: Hybrid mode,anisotropic along direction vector but radially isotropic
|
||||
perpendicularly. */
|
||||
|
||||
// Direction (default: (1,0,0))
|
||||
// Specifies the direction of anisotropy (used only if anisotropic is 1).
|
||||
|
||||
// bandwidth (default: 1.0)
|
||||
// Controls the frequency range of the noise.
|
||||
|
||||
// impulses (default: 16)
|
||||
// Controls the number of impulses used per cell, affecting detail level.
|
||||
|
||||
// do_filter (default: 1)
|
||||
// Enables/disables antialiasing (filtering).
|
||||
|
||||
result = noise(
|
||||
"gabor",
|
||||
P,
|
||||
"anisotropic", anisotropic,
|
||||
"direction", direction,
|
||||
"bandwidth", bandwidth,
|
||||
"impulses", impulses,
|
||||
"do_filter", do_filter
|
||||
);
|
||||
|
||||
// Specific noises can also be used instead of passing them as types
|
||||
// pnoise is periodic noise
|
||||
float n1 = pnoise("perlin", 0.5, 1.0);
|
||||
// 2D periodic noise with Gabor type
|
||||
float n2 = pnoise("gabor", 0.2, 0.3, 2.0, 3.0);
|
||||
// 2D non-periodic simplex noise
|
||||
float n3 = snoise(0.1, 0.7);
|
||||
// 2D periodic simplex noise
|
||||
type psnoise (float u, float v, float uperiod, float vperiod);
|
||||
float n4 = psnoise(0.4, 0.6, 0.5, 0.25);
|
||||
// 2D cellular noise
|
||||
float n5 = cellnoise(0.2, 0.8);
|
||||
// 2D hash noise
|
||||
int n6 = hash(0.7, 0.3);
|
||||
|
||||
// Step Function
|
||||
// Step Functions are used to compare input and threshold
|
||||
|
||||
// The type may be of float, color, point, vector, or normal.
|
||||
type step (type edge, type x); // Returns 1 if x ≥ edge, else 0
|
||||
color checker = step(0.5, P); // P is a point on the surface
|
||||
/* Pixels with P values below 0.5 will be black, those above or equal will
|
||||
be white */
|
||||
float visibility = step(10, distance(P, light_position));
|
||||
// Light is fully visible within 10 units, completely invisible beyond
|
||||
|
||||
type linearstep (type edge0, type edge1, type x); /* Linearstep Returns 0
|
||||
if x ≤ edge0, and 1 if x ≥ edge1, with linear interpolation */
|
||||
color gradient = linearstep(0, 1, P);
|
||||
// P is a point on the surface between 0 and 1
|
||||
// Color will graduate smoothly from black to white as P moves from 0 to 1
|
||||
float fade = linearstep(0.85, 1, N.z); // N.z is the z-component
|
||||
// Object edges with normals close to vertical (N.z near 1) will fade out
|
||||
|
||||
type smoothstep (type edge0, type edge1, type x); /* smoothstep Returns 0
|
||||
if x ≤ edge0, and 1 if x ≥ edge1, with Hermite interpolation */
|
||||
float soft_mask = smoothstep(0.2, 0.8, noise(P)); /* noise(P) is a noisy
|
||||
value between 0 and 1. soft_mask will vary smoothly between 0 and 1 based
|
||||
on noise(P), with a smoother curve than linearstep */
|
||||
|
||||
// Splines
|
||||
// Splines are smooth curves based on a set of control points
|
||||
|
||||
/* The type of interpolation ranges from "catmull-rom", "bezier",
|
||||
"bspline", "hermite", "linear", or "constant" */
|
||||
|
||||
// Spline with knot vector
|
||||
float[] knots = {0, 0, 0, 0.25, 0.5, 0.75, 1, 1, 1};
|
||||
point[] controls = {point(0),point(1, 2, 1),point(2, 1, 2),point(3, 3, 1)};
|
||||
spline curve1 = spline("bezier", 0.5, len(knots), controls);
|
||||
// curve1 is a Bezier spline evaluated at u = 0.5
|
||||
|
||||
// Spline with control points
|
||||
spline curve2 = spline("catmull-rom", 0.25, point(0, 0, 0), point(1, 2, 1),
|
||||
point(2, 1, 2), point(3, 3, 1));
|
||||
// curve2 is a Catmull-Rom spline evaluated at u = 0.25
|
||||
|
||||
// Constant spline with a single float value
|
||||
float value = 10;
|
||||
u = 0.1;
|
||||
spline curve5 = spline("constant", u, value);
|
||||
// curve5 is a constant spline with value 10 evaluated at u = 0.1
|
||||
|
||||
// Hermite spline with point and vector controls
|
||||
point q0 = point(0, 0, 0), q1 = point(3, 3, 3);
|
||||
vector t0 = vector(1, 0, 0), t1 = vector(-1, 1, 1);
|
||||
u = 0.75;
|
||||
spline curve3 = spline("hermite", u, q0, t0, q1, t1);
|
||||
// curve3 is a Hermite spline evaluated at u = 0.75
|
||||
|
||||
// Linear spline with float controls
|
||||
float f0 = 0, f1 = 1, f2 = 2, f3 = 3;
|
||||
u = 0.4;
|
||||
spline curve4 = spline("linear", u, f0, f1, f2, f3);
|
||||
// curve4 is a linear spline evaluated at u = 0.4
|
||||
|
||||
// InverseSplines also exist
|
||||
|
||||
// Inverse spline with control values
|
||||
float y0 = 0, y1 = 1, y2 = 2, y3 = 3;
|
||||
float v = 1.5;
|
||||
float u1 = splineinverse("linear", v, y0, y1, y2, y3);
|
||||
// u1 = 0.5 (linear interpolation between y1 and y2)
|
||||
|
||||
// Inverse spline with knot vector
|
||||
float[] knots = {0, 0, 0, 0.25, 0.5, 0.75, 1, 1, 1};
|
||||
float[] values = {0, 1, 4, 9};
|
||||
v = 6;
|
||||
float u2 = splineinverse("bezier", v, len(knots), values);
|
||||
// u2 = 0.75 (Bezier spline inverse evaluated at v = 6)
|
||||
|
||||
// Inverse spline with constant value
|
||||
v = 10;
|
||||
float u3 = splineinverse("constant", v, 10);
|
||||
// u3 = 0 (since the constant spline always returns 10)
|
||||
|
||||
// Inverse spline with periodic values
|
||||
float y4 = 0, y5 = 1, y6 = 0;
|
||||
v = 0.5;
|
||||
float u4 = splineinverse("periodic", v, y4, y5, y6);
|
||||
// u4 = 0.75 (periodic spline inverse evaluated at v = 0.5)
|
||||
|
||||
|
||||
|
||||
// Calculus Operators
|
||||
// Partial derivative of f with respect to x, y and z using Dx, Dy, Dz
|
||||
float a = 3.14;
|
||||
float dx = Dx(a); // partial derivative of a with respect to x
|
||||
|
||||
point p = point(1.0, 2.0, 3.0);
|
||||
vector dp_dx = Dx(p); // partial derivative of p with respect to x
|
||||
|
||||
vector dv_dy = Dy(N); // partial derivative of normal with respect to y
|
||||
|
||||
color c = color(0.5, 0.2, 0.8);
|
||||
color dc_dz = Dz(c); // partial derivative of c with respect to z
|
||||
|
||||
|
||||
float area (point p) // gives the surface area at the position p
|
||||
|
||||
float filterwidth (float x) // gives the changes of x in adjacent samples
|
||||
|
||||
// Texture Functions
|
||||
// lookup for a texture at coordinates (x,y)
|
||||
color col1 = texture("texture.png", 0.5, 0.2);
|
||||
// Lookup color at (0.5, 0.2) in texture.png
|
||||
|
||||
// 3D lookup for a texture at coordinates (x,y)
|
||||
color col3 = texture3d("texture3d.vdb", point(0.25, 0.5, 0.75));
|
||||
|
||||
// parameters are ("blur","width","wrap","fill","alpha","interp", ...)
|
||||
color col2 = texture("texture.png",1.0,0.75,"blur",0.1,"wrap", "periodic");
|
||||
// Lookup color at (1.0, 0.75) with blur 0.1 and periodic wrap mode
|
||||
|
||||
// Light Functions
|
||||
|
||||
float surfacearea (); // Returns the surface area of area light covers
|
||||
int backfacing (); // Outputs 1 if the normals are backfaced, else 0
|
||||
int raytype (string name); // returns 1 if the ray is a particular raytype
|
||||
|
||||
// Tracing a ray from a position in a direction
|
||||
point pos = point(0, 0, 0); // Starting position of the ray
|
||||
vector dir = vector(0, 0, 1); // Direction of the ray
|
||||
int hit = trace(pos, dir); // returns 1 if it hits, else 0
|
||||
|
||||
```
|
||||
### Further reading
|
||||
|
||||
* [Blender Docs for OSL](https://docs.blender.org/manual/en/latest/render/shader_nodes/osl.html)
|
||||
* [C4D Docs for OSL](https://docs.otoy.com/cinema4d//OpenShadingLanguageOSL.html)
|
||||
* Open Shading Language on [Github](https://github.com/AcademySoftwareFoundation/OpenShadingLanguage)
|
||||
* [Official OSL Documentation](https://open-shading-language.readthedocs.io/en/main/)
|
||||
Loading…
Reference in New Issue
Block a user