nightshade-renderer 0.57.0

GPU-driven wgpu renderer with a built-in frame graph.
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

#define_import_path nightshade_renderer::material_sampling

const NO_LAYER: u32 = 0xFFFFFFFFu;

struct UvGrad {
    ddx: vec2<f32>,
    ddy: vec2<f32>,
}

fn apply_wrap_axis(value: f32, mode: u32) -> f32 {
    if mode == 0u {
        return fract(value);
    } else if mode == 1u {
        let cycle = value - 2.0 * floor(value * 0.5);
        return min(cycle, 2.0 - cycle);
    }
    return clamp(value, 0.0, 1.0);
}

fn apply_wrap(uv: vec2<f32>, packed: u32) -> vec2<f32> {
    let mode_u = (packed >> 16u) & 0x3u;
    let mode_v = (packed >> 18u) & 0x3u;
    return vec2<f32>(apply_wrap_axis(uv.x, mode_u), apply_wrap_axis(uv.y, mode_v));
}

#ifdef BINDLESS

@group(2) @binding(0)
var material_textures: binding_array<texture_2d<f32>>;

@group(2) @binding(1)
var material_sampler_repeat: sampler;

@group(2) @binding(2)
var material_sampler_mirror: sampler;

@group(2) @binding(3)
var material_sampler_clamp: sampler;

fn sample_srgb_layer(packed: u32, uv: vec2<f32>, grad: UvGrad) -> vec4<f32> {
    if packed == NO_LAYER {
        return vec4<f32>(0.0);
    }
    let index = packed & 0xFFFFu;
    let mode_u = (packed >> 16u) & 0x3u;
    let mode_v = (packed >> 18u) & 0x3u;
    if mode_u == mode_v {
        switch mode_u {
            case 0u: {
                return textureSampleGrad(material_textures[index], material_sampler_repeat, uv, grad.ddx, grad.ddy);
            }
            case 1u: {
                return textureSampleGrad(material_textures[index], material_sampler_mirror, uv, grad.ddx, grad.ddy);
            }
            default: {
                return textureSampleGrad(material_textures[index], material_sampler_clamp, uv, grad.ddx, grad.ddy);
            }
        }
    }
    let wrapped = apply_wrap(uv, packed);
    return textureSampleGrad(material_textures[index], material_sampler_clamp, wrapped, grad.ddx, grad.ddy);
}

fn sample_linear_layer(packed: u32, uv: vec2<f32>, grad: UvGrad) -> vec4<f32> {
    if packed == NO_LAYER {
        return vec4<f32>(0.0);
    }
    let index = packed & 0xFFFFu;
    let mode_u = (packed >> 16u) & 0x3u;
    let mode_v = (packed >> 18u) & 0x3u;
    if mode_u == mode_v {
        switch mode_u {
            case 0u: {
                return textureSampleGrad(material_textures[index], material_sampler_repeat, uv, grad.ddx, grad.ddy);
            }
            case 1u: {
                return textureSampleGrad(material_textures[index], material_sampler_mirror, uv, grad.ddx, grad.ddy);
            }
            default: {
                return textureSampleGrad(material_textures[index], material_sampler_clamp, uv, grad.ddx, grad.ddy);
            }
        }
    }
    let wrapped = apply_wrap(uv, packed);
    return textureSampleGrad(material_textures[index], material_sampler_clamp, wrapped, grad.ddx, grad.ddy);
}

fn sample_srgb_index(layer: u32, uv: vec2<f32>) -> vec4<f32> {
    return textureSampleLevel(material_textures[layer], material_sampler_clamp, uv, 0.0);
}

#else

@group(2) @binding(0)
var material_srgb_array: texture_2d_array<f32>;

@group(2) @binding(1)
var material_linear_array: texture_2d_array<f32>;

@group(2) @binding(2)
var material_sampler_repeat: sampler;

@group(2) @binding(3)
var material_sampler_mirror: sampler;

@group(2) @binding(4)
var material_sampler_clamp: sampler;

fn sample_srgb_layer(packed: u32, uv: vec2<f32>, grad: UvGrad) -> vec4<f32> {
    if packed == NO_LAYER {
        return vec4<f32>(0.0);
    }
    let layer = packed & 0xFFFFu;
    let mode_u = (packed >> 16u) & 0x3u;
    let mode_v = (packed >> 18u) & 0x3u;
    if mode_u == mode_v {
        switch mode_u {
            case 0u: {
                return textureSampleGrad(material_srgb_array, material_sampler_repeat, uv, layer, grad.ddx, grad.ddy);
            }
            case 1u: {
                return textureSampleGrad(material_srgb_array, material_sampler_mirror, uv, layer, grad.ddx, grad.ddy);
            }
            default: {
                return textureSampleGrad(material_srgb_array, material_sampler_clamp, uv, layer, grad.ddx, grad.ddy);
            }
        }
    }
    let wrapped = apply_wrap(uv, packed);
    return textureSampleGrad(material_srgb_array, material_sampler_clamp, wrapped, layer, grad.ddx, grad.ddy);
}

fn sample_linear_layer(packed: u32, uv: vec2<f32>, grad: UvGrad) -> vec4<f32> {
    if packed == NO_LAYER {
        return vec4<f32>(0.0);
    }
    let layer = packed & 0xFFFFu;
    let mode_u = (packed >> 16u) & 0x3u;
    let mode_v = (packed >> 18u) & 0x3u;
    if mode_u == mode_v {
        switch mode_u {
            case 0u: {
                return textureSampleGrad(material_linear_array, material_sampler_repeat, uv, layer, grad.ddx, grad.ddy);
            }
            case 1u: {
                return textureSampleGrad(material_linear_array, material_sampler_mirror, uv, layer, grad.ddx, grad.ddy);
            }
            default: {
                return textureSampleGrad(material_linear_array, material_sampler_clamp, uv, layer, grad.ddx, grad.ddy);
            }
        }
    }
    let wrapped = apply_wrap(uv, packed);
    return textureSampleGrad(material_linear_array, material_sampler_clamp, wrapped, layer, grad.ddx, grad.ddy);
}

fn sample_srgb_index(layer: u32, uv: vec2<f32>) -> vec4<f32> {
    return textureSampleLevel(material_srgb_array, material_sampler_clamp, uv, layer, 0.0);
}

#endif