Flocking-Simulation/js-libs/CloudShader.js at master · techcentaur/Flocking-Simulation · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
/**
 * @author mattatz / http://github.com/mattatz
 *
 * Ray tracing based cloud noise shader.
 */

THREE.CloudShader = {

    defines: {
        "ITERATIONS"    : "8",
        "KAPPA"         : "0.2",
        "MOD3"          : "(.16532, .17369, .15787)",
    },

    uniforms: {
        "color"         : { type : "c",     value : null },
        "time"          : { type : "f",     value : 0.0 },
        "seed"          : { type : "f",     value : 0.0 },
        "invModelMatrix": { type : "m4",    value : null },
        "scale"         : { type : "v3",    value : null }
    },

    vertexShader: [
        "varying vec3 vWorldPos;",
        "void main() {",
            "gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);",
            "vWorldPos = (modelMatrix * vec4(position, 1.0)).xyz;",
        "}"
    ].join("\n"),

    fragmentShader: [

        "uniform vec3 color;",
        "uniform float time;",
        "uniform float seed;",
        "uniform mat4 invModelMatrix;",
        "uniform vec3 scale;",

        "varying vec3 vWorldPos;",

        "float hash(vec3 p) {",
            "p = fract(p * MOD3);",
            "p += dot(p.xyz, p.yzx + 19.19);",
            "return fract(p.x * p.y * p.z);",
        "}",

        "float noise(vec3 p) {",
            "vec3 i = floor(p);",
            "vec3 f = fract(p);",
            "f *= f * (3.0 - 2.0 * f);",
            "return mix(",
                "mix(",
                    "mix(hash(i + vec3(0.,0.,0.)), hash(i + vec3(1.,0.,0.)),f.x),",
                    "mix(hash(i + vec3(0.,1.,0.)), hash(i + vec3(1.,1.,0.)),f.x),",
                    "f.y",
                "),",
                "mix(",
                    "mix(hash(i + vec3(0.,0.,1.)), hash(i + vec3(1.,0.,1.)),f.x),",
                    "mix(hash(i + vec3(0.,1.,1.)), hash(i + vec3(1.,1.,1.)),f.x),",
                    "f.y",
                "),",
                "f.z",
            ");",
        "}",

        "float fbm(vec3 p) {",
            "float f;",

            "f = 0.5000 * noise(p);",
            "p = p * 3.02;",
            "p.y -= (seed + time) * 0.05;",

            "f += 0.2500 * noise(p);",
            "p = p * 3.03;",
            "p.y += (seed + time) * 0.06;",

            "f += 0.1250 * noise(p);",
            "p = p * 3.01;",

            "f += 0.0625   * noise(p);",
            "p =  p * 3.03;",

            "f += 0.03125  * noise(p);",
            "p =  p * 3.02;",

            "f += 0.015625 * noise(p);",

            "return f;",
        "}",

        "vec3 localize(vec3 p) {",
            "return (invModelMatrix * vec4(p, 1.0)).xyz;",
        "}",

        "void main() {",

            "vec3 rayPos = vWorldPos;",
            "vec3 rayDir = normalize(rayPos - cameraPosition);",
            "float rayLen = 0.1 * length(scale.xyz);",

            "float c = 0.0;",

            "float t = 1.0;",

            "for(int i = 0; i < ITERATIONS; i++) {",
                "rayPos += rayDir * rayLen;",

                "vec3 lp = localize(rayPos);",

                "float delta = exp(- KAPPA * rayLen);",
                "t *= delta;",

                "float den = fbm(lp);",
                "den = clamp(- length(lp) + den * 0.75, 0.0, 1.0);",
                "c += 1.0 / KAPPA * (1.0 - delta) * t * den;",
            "}",

            "gl_FragColor = vec4(pow(c, 0.5) * 9.0 * color, c * 80.0);",
        "}",

	].join("\n")

};