Merge branch 'master' into blender2.8
[blender.git] / intern / cycles / kernel / shaders / node_brick_texture.osl
1 /*
2  * Copyright 2011-2013 Blender Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include "stdosl.h"
18 #include "node_texture.h"
19
20 /* Brick */
21
22 float brick_noise(int ns) /* fast integer noise */
23 {
24         int nn;
25         int n = (ns + 1013) & 2147483647;
26         n = (n >> 13) ^ n;
27         nn = (n * (n * n * 60493 + 19990303) + 1376312589) & 2147483647;
28         return 0.5 * ((float)nn / 1073741824.0);
29 }
30
31 float brick(point p, float mortar_size, float mortar_smooth, float bias,
32         float BrickWidth, float row_height, float offset_amount, int offset_frequency,
33         float squash_amount, int squash_frequency, output float tint)
34 {
35         int bricknum, rownum;
36         float offset = 0.0;
37         float brick_width = BrickWidth;
38         float x, y;
39
40         rownum = (int)floor(p[1] / row_height);
41         
42         if (offset_frequency && squash_frequency) {
43                 brick_width *= (rownum % squash_frequency) ? 1.0 : squash_amount;                /* squash */
44                 offset       = (rownum % offset_frequency) ? 0.0 : (brick_width * offset_amount);  /* offset */
45         }
46
47         bricknum = (int)floor((p[0] + offset) / brick_width);
48
49         x = (p[0] + offset) - brick_width * bricknum;
50         y = p[1] - row_height * rownum;
51
52         tint = clamp((brick_noise((rownum << 16) + (bricknum & 65535)) + bias), 0.0, 1.0);
53
54         float min_dist = min(min(x, y), min(brick_width - x, row_height - y));
55         if(min_dist >= mortar_size) {
56                 return 0.0;
57         }
58         else if(mortar_smooth == 0.0) {
59                 return 1.0;
60         }
61         else {
62                 min_dist = 1.0 - min_dist/mortar_size;
63                 return smoothstep(0.0, mortar_smooth, min_dist);
64         }
65 }
66
67 shader node_brick_texture(
68         int use_mapping = 0,
69         matrix mapping = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
70         float offset = 0.5,
71         int offset_frequency = 2,
72         float squash = 1.0,
73         int squash_frequency = 1,
74         point Vector = P,
75         color Color1 = 0.2,
76         color Color2 = 0.8,
77         color Mortar = 0.0,
78         float Scale = 5.0,
79         float MortarSize = 0.02,
80         float MortarSmooth = 0.0,
81         float Bias = 0.0,
82         float BrickWidth = 0.5,
83         float RowHeight = 0.25,
84         output float Fac = 0.0,
85         output color Color = 0.2)
86 {
87         point p = Vector;
88
89         if (use_mapping)
90                 p = transform(mapping, p);
91
92         float tint = 0.0;
93         color Col = Color1;
94         
95         Fac = brick(p * Scale, MortarSize, MortarSmooth, Bias, BrickWidth, RowHeight,
96                 offset, offset_frequency, squash, squash_frequency, tint);
97                 
98         if (Fac != 1.0) {
99                 float facm = 1.0 - tint;
100                 Col = facm * Color1 + tint * Color2;
101         }
102         
103         Color = mix(Col, Mortar, Fac);
104 }
105