1#define_import_path bevy_render::view
2
3struct ColorGrading {
4    balance: mat3x3<f32>,
5    saturation: vec3<f32>,
6    contrast: vec3<f32>,
7    gamma: vec3<f32>,
8    gain: vec3<f32>,
9    lift: vec3<f32>,
10    midtone_range: vec2<f32>,
11    exposure: f32,
12    hue: f32,
13    post_saturation: f32,
14}
15
16struct View {
17    clip_from_world: mat4x4<f32>,
18    unjittered_clip_from_world: mat4x4<f32>,
19    world_from_clip: mat4x4<f32>,
20    world_from_view: mat4x4<f32>,
21    view_from_world: mat4x4<f32>,
22    // Typically a column-major right-handed projection matrix, one of either:
23    //
24    // Perspective (infinite reverse z)
25    // ```
26    // f = 1 / tan(fov_y_radians / 2)
27    //
28    // ⎡ f / aspect  0   0     0 ⎤
29    // ⎢          0  f   0     0 ⎥
30    // ⎢          0  0   0  near ⎥
31    // ⎣          0  0  -1     0 ⎦
32    // ```
33    //
34    // Orthographic
35    // ```
36    // w = right - left
37    // h = top - bottom
38    // d = far - near
39    // cw = -right - left
40    // ch = -top - bottom
41    //
42    // ⎡ 2 / w      0      0   cw / w ⎤
43    // ⎢     0  2 / h      0   ch / h ⎥
44    // ⎢     0      0  1 / d  far / d ⎥
45    // ⎣     0      0      0        1 ⎦
46    // ```
47    //
48    // `clip_from_view[3][3] == 1.0` is the standard way to check if a projection is orthographic
49    //
50    // Wgsl matrices are column major, so for example getting the near plane of a perspective projection is `clip_from_view[3][2]`
51    //
52    // Custom projections are also possible however.
53    clip_from_view: mat4x4<f32>,
54    view_from_clip: mat4x4<f32>,
55    world_position: vec3<f32>,
56    exposure: f32,
57    // viewport(x_origin, y_origin, width, height)
58    viewport: vec4<f32>,
59    main_pass_viewport: vec4<f32>,
60    // 6 world-space half spaces (normal: vec3, distance: f32) ordered left, right, top, bottom, near, far.
61    // The normal vectors point towards the interior of the frustum.
62    // A half space contains `p` if `normal.dot(p) + distance > 0.`
63    frustum: array<vec4<f32>, 6>,
64    color_grading: ColorGrading,
65    mip_bias: f32,
66    frame_count: u32,
67};
68
69/// World space:
70/// +y is up
71
72/// View space:
73/// -z is forward, +x is right, +y is up
74/// Forward is from the camera position into the scene.
75/// (0.0, 0.0, -1.0) is linear distance of 1.0 in front of the camera's view relative to the camera's rotation
76/// (0.0, 1.0, 0.0) is linear distance of 1.0 above the camera's view relative to the camera's rotation
77
78/// NDC (normalized device coordinate):
79/// https://www.w3.org/TR/webgpu/#coordinate-systems
80/// (-1.0, -1.0) in NDC is located at the bottom-left corner of NDC
81/// (1.0, 1.0) in NDC is located at the top-right corner of NDC
82/// Z is depth where:
83///    1.0 is near clipping plane
84///    Perspective projection: 0.0 is inf far away
85///    Orthographic projection: 0.0 is far clipping plane
86
87/// Clip space:
88/// This is NDC before the perspective divide, still in homogenous coordinate space.
89/// Dividing a clip space point by its w component yields a point in NDC space.
90
91/// UV space:
92/// 0.0, 0.0 is the top left
93/// 1.0, 1.0 is the bottom right
94
95
96// -----------------
97// TO WORLD --------
98// -----------------
99
100/// Convert a view space position to world space
101fn position_view_to_world(view_pos: vec3<f32>, world_from_view: mat4x4<f32>) -> vec3<f32> {
102    let world_pos = world_from_view * vec4(view_pos, 1.0);
103    return world_pos.xyz;
104}
105
106/// Convert a clip space position to world space
107fn position_clip_to_world(clip_pos: vec4<f32>, world_from_clip: mat4x4<f32>) -> vec3<f32> {
108    let world_pos = world_from_clip * clip_pos;
109    return world_pos.xyz;
110}
111
112/// Convert a ndc space position to world space
113fn position_ndc_to_world(ndc_pos: vec3<f32>, world_from_clip: mat4x4<f32>) -> vec3<f32> {
114    let world_pos = world_from_clip * vec4(ndc_pos, 1.0);
115    return world_pos.xyz / world_pos.w;
116}
117
118/// Convert a view space direction to world space
119fn direction_view_to_world(view_dir: vec3<f32>, world_from_view: mat4x4<f32>) -> vec3<f32> {
120    let world_dir = world_from_view * vec4(view_dir, 0.0);
121    return world_dir.xyz;
122}
123
124/// Convert a clip space direction to world space
125fn direction_clip_to_world(clip_dir: vec4<f32>, world_from_clip: mat4x4<f32>) -> vec3<f32> {
126    let world_dir = world_from_clip * clip_dir;
127    return world_dir.xyz;
128}
129
130// -----------------
131// TO VIEW ---------
132// -----------------
133
134/// Convert a world space position to view space
135fn position_world_to_view(world_pos: vec3<f32>, view_from_world: mat4x4<f32>) -> vec3<f32> {
136    let view_pos = view_from_world * vec4(world_pos, 1.0);
137    return view_pos.xyz;
138}
139
140/// Convert a clip space position to view space
141fn position_clip_to_view(clip_pos: vec4<f32>, view_from_clip: mat4x4<f32>) -> vec3<f32> {
142    let view_pos = view_from_clip * clip_pos;
143    return view_pos.xyz;
144}
145
146/// Convert a ndc space position to view space
147fn position_ndc_to_view(ndc_pos: vec3<f32>, view_from_clip: mat4x4<f32>) -> vec3<f32> {
148    let view_pos = view_from_clip * vec4(ndc_pos, 1.0);
149    return view_pos.xyz / view_pos.w;
150}
151
152/// Convert a world space direction to view space
153fn direction_world_to_view(world_dir: vec3<f32>, view_from_world: mat4x4<f32>) -> vec3<f32> {
154    let view_dir = view_from_world * vec4(world_dir, 0.0);
155    return view_dir.xyz;
156}
157
158/// Convert a clip space direction to view space
159fn direction_clip_to_view(clip_dir: vec4<f32>, view_from_clip: mat4x4<f32>) -> vec3<f32> {
160    let view_dir = view_from_clip * clip_dir;
161    return view_dir.xyz;
162}
163
164// -----------------
165// TO CLIP ---------
166// -----------------
167
168/// Convert a world space position to clip space
169fn position_world_to_clip(world_pos: vec3<f32>, clip_from_world: mat4x4<f32>) -> vec4<f32> {
170    let clip_pos = clip_from_world * vec4(world_pos, 1.0);
171    return clip_pos;
172}
173
174/// Convert a view space position to clip space
175fn position_view_to_clip(view_pos: vec3<f32>, clip_from_view: mat4x4<f32>) -> vec4<f32> {
176    let clip_pos = clip_from_view * vec4(view_pos, 1.0);
177    return clip_pos;
178}
179
180/// Convert a world space direction to clip space
181fn direction_world_to_clip(world_dir: vec3<f32>, clip_from_world: mat4x4<f32>) -> vec4<f32> {
182    let clip_dir = clip_from_world * vec4(world_dir, 0.0);
183    return clip_dir;
184}
185
186/// Convert a view space direction to clip space
187fn direction_view_to_clip(view_dir: vec3<f32>, clip_from_view: mat4x4<f32>) -> vec4<f32> {
188    let clip_dir = clip_from_view * vec4(view_dir, 0.0);
189    return clip_dir;
190}
191
192// -----------------
193// TO NDC ----------
194// -----------------
195
196/// Convert a world space position to ndc space
197fn position_world_to_ndc(world_pos: vec3<f32>, clip_from_world: mat4x4<f32>) -> vec3<f32> {
198    let ndc_pos = clip_from_world * vec4(world_pos, 1.0);
199    return ndc_pos.xyz / ndc_pos.w;
200}
201
202/// Convert a view space position to ndc space
203fn position_view_to_ndc(view_pos: vec3<f32>, clip_from_view: mat4x4<f32>) -> vec3<f32> {
204    let ndc_pos = clip_from_view * vec4(view_pos, 1.0);
205    return ndc_pos.xyz / ndc_pos.w;
206}
207
208// -----------------
209// DEPTH -----------
210// -----------------
211
212/// Retrieve the perspective camera near clipping plane
213fn perspective_camera_near(clip_from_view: mat4x4<f32>) -> f32 {
214    return clip_from_view[3][2];
215}
216
217/// Convert ndc depth to linear view z.
218/// Note: Depth values in front of the camera will be negative as -z is forward
219fn depth_ndc_to_view_z(ndc_depth: f32, clip_from_view: mat4x4<f32>, view_from_clip: mat4x4<f32>) -> f32 {
220#ifdef VIEW_PROJECTION_PERSPECTIVE
221    return -perspective_camera_near(clip_from_view) / ndc_depth;
222#else ifdef VIEW_PROJECTION_ORTHOGRAPHIC
223    return -(clip_from_view[3][2] - ndc_depth) / clip_from_view[2][2];
224#else
225    let view_pos = view_from_clip * vec4(0.0, 0.0, ndc_depth, 1.0);
226    return view_pos.z / view_pos.w;
227#endif
228}
229
230/// Convert linear view z to ndc depth.
231/// Note: View z input should be negative for values in front of the camera as -z is forward
232fn view_z_to_depth_ndc(view_z: f32, clip_from_view: mat4x4<f32>) -> f32 {
233#ifdef VIEW_PROJECTION_PERSPECTIVE
234    return -perspective_camera_near(clip_from_view) / view_z;
235#else ifdef VIEW_PROJECTION_ORTHOGRAPHIC
236    return clip_from_view[3][2] + view_z * clip_from_view[2][2];
237#else
238    let ndc_pos = clip_from_view * vec4(0.0, 0.0, view_z, 1.0);
239    return ndc_pos.z / ndc_pos.w;
240#endif
241}
242
243// -----------------
244// UV --------------
245// -----------------
246
247/// Convert ndc space xy coordinate [-1.0 .. 1.0] to uv [0.0 .. 1.0]
248fn ndc_to_uv(ndc: vec2<f32>) -> vec2<f32> {
249    return ndc * vec2(0.5, -0.5) + vec2(0.5);
250}
251
252/// Convert uv [0.0 .. 1.0] coordinate to ndc space xy [-1.0 .. 1.0]
253fn uv_to_ndc(uv: vec2<f32>) -> vec2<f32> {
254    return uv * vec2(2.0, -2.0) + vec2(-1.0, 1.0);
255}
256
257/// returns the (0.0, 0.0) .. (1.0, 1.0) position within the viewport for the current render target
258/// [0 .. render target viewport size] eg. [(0.0, 0.0) .. (1280.0, 720.0)] to [(0.0, 0.0) .. (1.0, 1.0)]
259fn frag_coord_to_uv(frag_coord: vec2<f32>, viewport: vec4<f32>) -> vec2<f32> {
260    return (frag_coord - viewport.xy) / viewport.zw;
261}
262
263/// Convert frag coord to ndc
264fn frag_coord_to_ndc(frag_coord: vec4<f32>, viewport: vec4<f32>) -> vec3<f32> {
265    return vec3(uv_to_ndc(frag_coord_to_uv(frag_coord.xy, viewport)), frag_coord.z);
266}
267
268/// Convert ndc space xy coordinate [-1.0 .. 1.0] to [0 .. render target
269/// viewport size]
270fn ndc_to_frag_coord(ndc: vec2<f32>, viewport: vec4<f32>) -> vec2<f32> {
271    return ndc_to_uv(ndc) * viewport.zw;
272}