The open source OpenXR runtime
c/util: CS renderer improve consistency/similarity to GFX
Part-of: <https://gitlab.freedesktop.org/monado/monado/-/merge_requests/2323>
authored by
Rylie Pavlik
and committed by
Marge Bot
6c73d381
7ec043ee
+20
-28
+20
-28
src/xrt/compositor/util/comp_render_cs.c
+20
-28
src/xrt/compositor/util/comp_render_cs.c
···
54
54
}
55
55
56
56
static inline void
57
-
do_cs_equirect2_layer(const struct xrt_layer_data *data,
58
-
const struct comp_layer *layer,
57
+
do_cs_equirect2_layer(const struct comp_layer *layer,
59
58
const struct xrt_matrix_4x4 *eye_view_mat,
60
59
const struct xrt_matrix_4x4 *world_view_mat,
61
60
uint32_t view_index,
···
75
74
76
75
// Image to use.
77
76
src_samplers[cur_image] = clamp_to_edge;
78
-
src_image_views[cur_image] = get_image_view(image, data->flags, array_index);
77
+
src_image_views[cur_image] = get_image_view(image, layer_data->flags, array_index);
79
78
80
79
// Used for Subimage and OpenGL flip.
81
80
set_post_transform_rect( //
82
-
data, // data
81
+
layer_data, // data
83
82
&eq2->sub.norm_rect, // src_norm_rect
84
83
false, // invert_flip
85
84
&ubo_data->post_transforms[cur_layer]); // out_norm_rect
···
92
91
struct xrt_matrix_4x4 model_inv;
93
92
math_matrix_4x4_inverse(&model, &model_inv);
94
93
95
-
const struct xrt_matrix_4x4 *v = is_layer_view_space(data) ? eye_view_mat : world_view_mat;
94
+
const struct xrt_matrix_4x4 *v = is_layer_view_space(layer_data) ? eye_view_mat : world_view_mat;
96
95
97
96
struct xrt_matrix_4x4 v_inv;
98
97
math_matrix_4x4_inverse(v, &v_inv);
···
117
116
}
118
117
119
118
static inline void
120
-
do_cs_projection_layer(const struct xrt_layer_data *data,
121
-
const struct comp_layer *layer,
119
+
do_cs_projection_layer(const struct comp_layer *layer,
122
120
const struct xrt_pose *world_pose,
123
121
uint32_t view_index,
124
122
uint32_t cur_layer,
···
147
145
148
146
// Color
149
147
src_samplers[cur_image] = clamp_to_border_black;
150
-
src_image_views[cur_image] = get_image_view(image, data->flags, array_index);
148
+
src_image_views[cur_image] = get_image_view(image, layer_data->flags, array_index);
151
149
ubo_data->images_samplers[cur_layer + 0].images[0] = cur_image++;
152
150
153
151
// Depth
154
-
if (data->type == XRT_LAYER_PROJECTION_DEPTH) {
152
+
if (layer_data->type == XRT_LAYER_PROJECTION_DEPTH) {
155
153
uint32_t d_array_index = dvd->sub.array_index;
156
154
const struct comp_swapchain_image *d_image =
157
155
get_layer_depth_image(layer, sc_array_index, dvd->sub.image_index);
158
156
159
157
src_samplers[cur_image] = clamp_to_edge; // Edge to keep depth stable at edges.
160
-
src_image_views[cur_image] = get_image_view(d_image, data->flags, d_array_index);
158
+
src_image_views[cur_image] = get_image_view(d_image, layer_data->flags, d_array_index);
161
159
ubo_data->images_samplers[cur_layer + 0].images[1] = cur_image++;
162
160
}
163
161
164
162
set_post_transform_rect( //
165
-
data, // data
163
+
layer_data, // data
166
164
&vd->sub.norm_rect, // src_norm_rect
167
165
false, // invert_flip
168
166
&ubo_data->post_transforms[cur_layer]); // out_norm_rect
···
180
178
}
181
179
182
180
static inline void
183
-
do_cs_quad_layer(const struct xrt_layer_data *data,
184
-
const struct comp_layer *layer,
181
+
do_cs_quad_layer(const struct comp_layer *layer,
185
182
const struct xrt_matrix_4x4 *eye_view_mat,
186
183
const struct xrt_matrix_4x4 *world_view_mat,
187
184
uint32_t view_index,
···
201
198
202
199
// Image to use.
203
200
src_samplers[cur_image] = clamp_to_edge;
204
-
src_image_views[cur_image] = get_image_view(image, data->flags, array_index);
201
+
src_image_views[cur_image] = get_image_view(image, layer_data->flags, array_index);
205
202
206
203
// Set the normalized post transform values.
207
204
struct xrt_normalized_rect post_transform = XRT_STRUCT_INIT;
208
205
set_post_transform_rect( //
209
-
data, // data
206
+
layer_data, // data
210
207
&q->sub.norm_rect, // src_norm_rect
211
208
true, // invert_flip
212
209
&post_transform); // out_norm_rect
213
210
214
211
// Is this layer viewspace or not.
215
-
const struct xrt_matrix_4x4 *view_mat = is_layer_view_space(data) ? eye_view_mat : world_view_mat;
212
+
const struct xrt_matrix_4x4 *view_mat = is_layer_view_space(layer_data) ? eye_view_mat : world_view_mat;
216
213
217
214
// Transform quad pose into view space.
218
215
struct xrt_vec3 quad_position = XRT_STRUCT_INIT;
219
-
math_matrix_4x4_transform_vec3(view_mat, &data->quad.pose.position, &quad_position);
216
+
math_matrix_4x4_transform_vec3(view_mat, &layer_data->quad.pose.position, &quad_position);
220
217
221
218
// neutral quad layer faces +z, towards the user
222
219
struct xrt_vec3 normal = (struct xrt_vec3){.x = 0, .y = 0, .z = 1};
223
220
224
221
// rotation of the quad normal in world space
225
-
struct xrt_quat rotation = data->quad.pose.orientation;
222
+
struct xrt_quat rotation = layer_data->quad.pose.orientation;
226
223
math_quat_rotate_vec3(&rotation, &normal, &normal);
227
224
228
225
/*
···
239
236
* normal_view_space = combined_normal [in view space] - plane_origin [in view space]
240
237
*/
241
238
struct xrt_vec3 normal_view_space = normal;
242
-
math_vec3_accum(&data->quad.pose.position, &normal_view_space);
239
+
math_vec3_accum(&layer_data->quad.pose.position, &normal_view_space);
243
240
math_matrix_4x4_transform_vec3(view_mat, &normal_view_space, &normal_view_space);
244
241
math_vec3_subtract(&quad_position, &normal_view_space);
245
242
246
243
struct xrt_vec3 scale = {1.f, 1.f, 1.f};
247
244
struct xrt_matrix_4x4 plane_transform_view_space, inverse_quad_transform;
248
-
math_matrix_4x4_model(&data->quad.pose, &scale, &plane_transform_view_space);
245
+
math_matrix_4x4_model(&layer_data->quad.pose, &scale, &plane_transform_view_space);
249
246
math_matrix_4x4_multiply(view_mat, &plane_transform_view_space, &plane_transform_view_space);
250
247
math_matrix_4x4_inverse(&plane_transform_view_space, &inverse_quad_transform);
251
248
252
249
// Write all of the UBO data.
253
250
ubo_data->post_transforms[cur_layer] = post_transform;
254
-
ubo_data->quad_extent[cur_layer].val = data->quad.size;
251
+
ubo_data->quad_extent[cur_layer].val = layer_data->quad.size;
255
252
ubo_data->quad_position[cur_layer].val = quad_position;
256
253
ubo_data->quad_normal[cur_layer].val = normal_view_space;
257
254
ubo_data->inverse_quad_transform[cur_layer] = inverse_quad_transform;
···
263
260
264
261
265
262
static inline void
266
-
do_cs_cylinder_layer(const struct xrt_layer_data *data,
267
-
const struct comp_layer *layer,
263
+
do_cs_cylinder_layer(const struct comp_layer *layer,
268
264
const struct xrt_matrix_4x4 *eye_view_mat,
269
265
const struct xrt_matrix_4x4 *world_view_mat,
270
266
uint32_t view_index,
···
284
280
285
281
// Image to use.
286
282
src_samplers[cur_image] = clamp_to_edge;
287
-
src_image_views[cur_image] = get_image_view(image, data->flags, array_index);
283
+
src_image_views[cur_image] = get_image_view(image, layer_data->flags, array_index);
288
284
289
285
// Used for Subimage and OpenGL flip.
290
286
set_post_transform_rect( //
···
560
556
switch (data->type) {
561
557
case XRT_LAYER_CYLINDER:
562
558
do_cs_cylinder_layer( //
563
-
data, // data
564
559
layer, // layer
565
560
&eye_view_mat, // eye_view_mat
566
561
&world_view_mat, // world_view_mat
···
576
571
break;
577
572
case XRT_LAYER_EQUIRECT2:
578
573
do_cs_equirect2_layer( //
579
-
data, // data
580
574
layer, // layer
581
575
&eye_view_mat, // eye_view_mat
582
576
&world_view_mat, // world_view_mat
···
593
587
case XRT_LAYER_PROJECTION_DEPTH:
594
588
case XRT_LAYER_PROJECTION: {
595
589
do_cs_projection_layer( //
596
-
data, // data
597
590
layer, // layer
598
591
world_pose, // world_pose
599
592
view_index, // view_index
···
609
602
} break;
610
603
case XRT_LAYER_QUAD: {
611
604
do_cs_quad_layer( //
612
-
data, // data
613
605
layer, // layer
614
606
&eye_view_mat, // eye_view_mat
615
607
&world_view_mat, // world_view_mat