mirrors/monado
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/monado/monado.git synced 2024-12-28 02:26:16 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

src: Consistently append 2 to equirect2 code.

Browse source 
Rename XRT_FEATURE_OPENXR_LAYER_EQUIRECT to XRT_FEATURE_OPENXR_LAYER_EQUIRECT2.
Rename equirect to equirect2.
Rename shader files.
This commit is contained in:
Lubosz Sarnecki 2020-12-02 14:20:54 +01:00 committed by Jakob Bornecrantz
parent b2337469a4
commit f334b8b6c7
26 changed files with 138 additions and 137 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
CMakeLists.txt
View file

@ -144,8 +144,8 @@ endif()
if(NOT DEFINED XRT_FEATURE_OPENXR_LAYER_CYLINDER)
set(XRT_FEATURE_OPENXR_LAYER_CYLINDER ON)
endif()
if(NOT DEFINED XRT_FEATURE_OPENXR_LAYER_EQUIRECT)
set(XRT_FEATURE_OPENXR_LAYER_EQUIRECT ON)
if(NOT DEFINED XRT_FEATURE_OPENXR_LAYER_EQUIRECT2)
set(XRT_FEATURE_OPENXR_LAYER_EQUIRECT2 ON)
endif()
if(NOT DEFINED XRT_FEATURE_OPENXR_LAYER_EQUIRECT_LEGACY)
set(XRT_FEATURE_OPENXR_LAYER_EQUIRECT_LEGACY OFF)
@ -303,7 +303,7 @@ message(STATUS "# FEATURE_OPENXR: ${XRT_FEATURE_OPENXR}
message(STATUS "# FEATURE_OPENXR_LAYER_DEPTH: ${XRT_FEATURE_OPENXR_LAYER_DEPTH}")
message(STATUS "# FEATURE_OPENXR_LAYER_CUBE: ${XRT_FEATURE_OPENXR_LAYER_CUBE}")
message(STATUS "# FEATURE_OPENXR_LAYER_CYLINDER: ${XRT_FEATURE_OPENXR_LAYER_CYLINDER}")
message(STATUS "# FEATURE_OPENXR_LAYER_EQUIRECT: ${XRT_FEATURE_OPENXR_LAYER_EQUIRECT}")
message(STATUS "# FEATURE_OPENXR_LAYER_EQUIRECT2: ${XRT_FEATURE_OPENXR_LAYER_EQUIRECT2}")
message(STATUS "# FEATURE_OPENXR_LAYER_EQUIRECT_LEGACY: ${XRT_FEATURE_OPENXR_LAYER_EQUIRECT_LEGACY}")
message(STATUS "# FEATURE_STEAMVR_PLUGIN: ${XRT_FEATURE_STEAMVR_PLUGIN}")
message(STATUS "#")

2
scripts/generate_oxr_ext_support.py
View file

@ -19,7 +19,7 @@ EXTENSIONS = (
['XR_KHR_composition_layer_cube', 'XRT_FEATURE_OPENXR_LAYER_CUBE'],
['XR_KHR_composition_layer_cylinder', 'XRT_FEATURE_OPENXR_LAYER_CYLINDER'],
['XR_KHR_composition_layer_equirect', 'XRT_FEATURE_OPENXR_LAYER_EQUIRECT_LEGACY'],
['XR_KHR_composition_layer_equirect2', 'XRT_FEATURE_OPENXR_LAYER_EQUIRECT'],
['XR_KHR_composition_layer_equirect2', 'XRT_FEATURE_OPENXR_LAYER_EQUIRECT2'],
['XR_EXT_debug_utils'],
['XR_MND_headless'],
['XR_MND_swapchain_usage_input_attachment_bit'],

4
src/xrt/compositor/CMakeLists.txt
View file

@ -6,8 +6,8 @@ spirv_shaders(SHADER_HEADERS
shaders/mesh.vert
shaders/layer.frag
shaders/layer.vert
shaders/equirect.vert
shaders/equirect.frag
shaders/equirect2.vert
shaders/equirect2.frag
)
set(CLIENT_SOURCE_FILES)

14
src/xrt/compositor/client/comp_gl_client.c
View file

@ -263,22 +263,22 @@ client_gl_compositor_layer_cylinder(struct xrt_compositor *xc,
}
static xrt_result_t
client_gl_compositor_layer_equirect(struct xrt_compositor *xc,
struct xrt_device *xdev,
struct xrt_swapchain *xsc,
const struct xrt_layer_data *data)
client_gl_compositor_layer_equirect2(struct xrt_compositor *xc,
struct xrt_device *xdev,
struct xrt_swapchain *xsc,
const struct xrt_layer_data *data)
{
struct client_gl_compositor *c = client_gl_compositor(xc);
struct xrt_swapchain *xscfb;
assert(data->type == XRT_LAYER_EQUIRECT);
assert(data->type == XRT_LAYER_EQUIRECT2);
xscfb = &client_gl_swapchain(xsc)->xscn->base;
struct xrt_layer_data d = *data;
d.flip_y = !d.flip_y;
return xrt_comp_layer_equirect(&c->xcn->base, xdev, xscfb, &d);
return xrt_comp_layer_equirect2(&c->xcn->base, xdev, xscfb, &d);
}
static xrt_result_t
@ -442,7 +442,7 @@ client_gl_compositor_init(struct client_gl_compositor *c,
c->base.base.layer_quad = client_gl_compositor_layer_quad;
c->base.base.layer_cube = client_gl_compositor_layer_cube;
c->base.base.layer_cylinder = client_gl_compositor_layer_cylinder;
c->base.base.layer_equirect = client_gl_compositor_layer_equirect;
c->base.base.layer_equirect2 = client_gl_compositor_layer_equirect2;
c->base.base.layer_commit = client_gl_compositor_layer_commit;
c->base.base.destroy = client_gl_compositor_destroy;
c->base.base.poll_events = client_gl_compositor_poll_events;

14
src/xrt/compositor/client/comp_vk_client.c
View file

@ -330,19 +330,19 @@ client_vk_compositor_layer_cylinder(struct xrt_compositor *xc,
}
static xrt_result_t
client_vk_compositor_layer_equirect(struct xrt_compositor *xc,
struct xrt_device *xdev,
struct xrt_swapchain *xsc,
const struct xrt_layer_data *data)
client_vk_compositor_layer_equirect2(struct xrt_compositor *xc,
struct xrt_device *xdev,
struct xrt_swapchain *xsc,
const struct xrt_layer_data *data)
{
struct client_vk_compositor *c = client_vk_compositor(xc);
struct xrt_swapchain *xscfb;
assert(data->type == XRT_LAYER_EQUIRECT);
assert(data->type == XRT_LAYER_EQUIRECT2);
xscfb = &client_vk_swapchain(xsc)->xscn->base;
return xrt_comp_layer_equirect(&c->xcn->base, xdev, xscfb, data);
return xrt_comp_layer_equirect2(&c->xcn->base, xdev, xscfb, data);
}
static xrt_result_t
@ -541,7 +541,7 @@ client_vk_compositor_create(struct xrt_compositor_native *xcn,
c->base.base.layer_quad = client_vk_compositor_layer_quad;
c->base.base.layer_cube = client_vk_compositor_layer_cube;
c->base.base.layer_cylinder = client_vk_compositor_layer_cylinder;
c->base.base.layer_equirect = client_vk_compositor_layer_equirect;
c->base.base.layer_equirect2 = client_vk_compositor_layer_equirect2;
c->base.base.layer_commit = client_vk_compositor_layer_commit;
c->base.base.destroy = client_vk_compositor_destroy;
c->base.base.poll_events = client_vk_compositor_poll_events;

18
src/xrt/compositor/main/comp_compositor.c
View file

@ -441,10 +441,10 @@ compositor_layer_cylinder(struct xrt_compositor *xc,
}
static xrt_result_t
compositor_layer_equirect(struct xrt_compositor *xc,
struct xrt_device *xdev,
struct xrt_swapchain *xsc,
const struct xrt_layer_data *data)
compositor_layer_equirect2(struct xrt_compositor *xc,
struct xrt_device *xdev,
struct xrt_swapchain *xsc,
const struct xrt_layer_data *data)
{
return do_single(xc, xdev, xsc, data);
}
@ -513,12 +513,12 @@ compositor_layer_commit(struct xrt_compositor *xc, int64_t frame_id)
image = &layer->scs[0]->images[cyl->sub.image_index];
comp_renderer_set_cylinder_layer(c->r, i, image, data);
} break;
case XRT_LAYER_EQUIRECT: {
struct xrt_layer_equirect_data *eq =
&layer->data.equirect;
case XRT_LAYER_EQUIRECT2: {
struct xrt_layer_equirect2_data *eq =
&layer->data.equirect2;
struct comp_swapchain_image *image;
image = &layer->scs[0]->images[eq->sub.image_index];
comp_renderer_set_equirect_layer(c->r, i, image, data);
comp_renderer_set_equirect2_layer(c->r, i, image, data);
} break;
case XRT_LAYER_CUBE:
// Should never end up here.
@ -1308,7 +1308,7 @@ xrt_gfx_provider_create_native(struct xrt_device *xdev)
c->base.base.layer_quad = compositor_layer_quad;
c->base.base.layer_cube = compositor_layer_cube;
c->base.base.layer_cylinder = compositor_layer_cylinder;
c->base.base.layer_equirect = compositor_layer_equirect;
c->base.base.layer_equirect2 = compositor_layer_equirect2;
c->base.base.layer_commit = compositor_layer_commit;
c->base.base.poll_events = compositor_poll_events;
c->base.base.destroy = compositor_destroy;

4
src/xrt/compositor/main/comp_compositor.h
View file

@ -141,8 +141,8 @@ struct comp_shaders
VkShaderModule mesh_vert;
VkShaderModule mesh_frag;
VkShaderModule equirect_vert;
VkShaderModule equirect_frag;
VkShaderModule equirect2_vert;
VkShaderModule equirect2_frag;
VkShaderModule layer_vert;
VkShaderModule layer_frag;

34
src/xrt/compositor/main/comp_layer.c
View file

@ -84,7 +84,7 @@ _init_ubos(struct comp_render_layer *self)
}
static bool
_init_equirect_ubo(struct comp_render_layer *self)
_init_equirect2_ubo(struct comp_render_layer *self)
{
VkBufferUsageFlags usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
VkMemoryPropertyFlags properties =
@ -93,17 +93,17 @@ _init_equirect_ubo(struct comp_render_layer *self)
VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
if (!vk_buffer_init(self->vk, sizeof(struct layer_transformation),
usage, properties, &self->equirect_ubo.handle,
&self->equirect_ubo.memory))
usage, properties, &self->equirect2_ubo.handle,
&self->equirect2_ubo.memory))
return false;
VkResult res = self->vk->vkMapMemory(
self->vk->device, self->equirect_ubo.memory, 0, VK_WHOLE_SIZE, 0,
&self->equirect_ubo.data);
self->vk->device, self->equirect2_ubo.memory, 0, VK_WHOLE_SIZE, 0,
&self->equirect2_ubo.data);
vk_check_error("vkMapMemory", res, false);
memcpy(self->equirect_ubo.data, &self->equirect_data,
sizeof(struct layer_equirect_data));
memcpy(self->equirect2_ubo.data, &self->equirect2_data,
sizeof(struct layer_equirect2_data));
return true;
}
@ -188,20 +188,20 @@ comp_layer_update_descriptors(struct comp_render_layer *self,
}
void
comp_layer_update_equirect_descriptor(struct comp_render_layer *self,
struct xrt_layer_equirect_data *data)
comp_layer_update_equirect2_descriptor(struct comp_render_layer *self,
struct xrt_layer_equirect2_data *data)
{
_update_descriptor_equirect(self, self->descriptor_equirect,
self->equirect_ubo.handle);
self->equirect2_ubo.handle);
self->equirect_data = (struct layer_equirect_data){
self->equirect2_data = (struct layer_equirect2_data){
.radius = data->radius,
.central_horizontal_angle = data->central_horizontal_angle,
.upper_vertical_angle = data->upper_vertical_angle,
.lower_vertical_angle = data->lower_vertical_angle,
};
memcpy(self->equirect_ubo.data, &self->equirect_data,
sizeof(struct layer_equirect_data));
memcpy(self->equirect2_ubo.data, &self->equirect2_data,
sizeof(struct layer_equirect2_data));
}
void
@ -236,7 +236,7 @@ _init(struct comp_render_layer *self,
if (!_init_ubos(self))
return false;
if (!_init_equirect_ubo(self))
if (!_init_equirect2_ubo(self))
return false;
VkDescriptorPoolSize pool_sizes[] = {
@ -301,7 +301,7 @@ comp_layer_draw(struct comp_render_layer *self,
break;
case XRT_LAYER_QUAD:
case XRT_LAYER_CYLINDER:
case XRT_LAYER_EQUIRECT: _update_mvp_matrix(self, eye, vp); break;
case XRT_LAYER_EQUIRECT2: _update_mvp_matrix(self, eye, vp); break;
case XRT_LAYER_STEREO_PROJECTION_DEPTH:
case XRT_LAYER_CUBE:
// Should never end up here.
@ -309,7 +309,7 @@ comp_layer_draw(struct comp_render_layer *self,
}
if (self->type == XRT_LAYER_EQUIRECT) {
if (self->type == XRT_LAYER_EQUIRECT2) {
const VkDescriptorSet sets[2] = {
self->descriptor_sets[eye],
self->descriptor_equirect,
@ -477,7 +477,7 @@ comp_layer_destroy(struct comp_render_layer *self)
for (uint32_t eye = 0; eye < 2; eye++)
vk_buffer_destroy(&self->transformation_ubos[eye], self->vk);
vk_buffer_destroy(&self->equirect_ubo, self->vk);
vk_buffer_destroy(&self->equirect2_ubo, self->vk);
self->vk->vkDestroyDescriptorPool(self->vk->device,
self->descriptor_pool, NULL);

10
src/xrt/compositor/main/comp_layer.h
View file

@ -20,7 +20,7 @@ struct layer_transformation
bool flip_y;
};
struct layer_equirect_data
struct layer_equirect2_data
{
float radius;
float central_horizontal_angle;
@ -41,8 +41,8 @@ struct comp_render_layer
struct layer_transformation transformation[2];
struct vk_buffer transformation_ubos[2];
struct layer_equirect_data equirect_data;
struct vk_buffer equirect_ubo;
struct layer_equirect2_data equirect2_data;
struct vk_buffer equirect2_ubo;
VkDescriptorPool descriptor_pool;
VkDescriptorSet descriptor_sets[2];
@ -105,5 +105,5 @@ comp_layer_update_cylinder_vertex_buffer(struct comp_render_layer *self,
float central_angle);
void
comp_layer_update_equirect_descriptor(struct comp_render_layer *self,
struct xrt_layer_equirect_data *data);
comp_layer_update_equirect2_descriptor(struct comp_render_layer *self,
struct xrt_layer_equirect2_data *data);

10
src/xrt/compositor/main/comp_layer_renderer.c
View file

@ -407,8 +407,8 @@ _render_eye(struct comp_layer_renderer *self,
? self->pipeline_premultiplied_alpha
: self->pipeline_unpremultiplied_alpha;
if (self->layers[i]->type == XRT_LAYER_EQUIRECT) {
pipeline = self->pipeline_equirect;
if (self->layers[i]->type == XRT_LAYER_EQUIRECT2) {
pipeline = self->pipeline_equirect2;
comp_layer_draw(self->layers[i], eye, pipeline,
pipeline_layout, cmd_buffer,
vertex_buffer, &vp_inv, &vp_inv);
@ -553,8 +553,8 @@ _init(struct comp_layer_renderer *self,
return false;
}
if (!_init_graphics_pipeline(self, s->equirect_vert, s->equirect_frag,
true, &self->pipeline_equirect)) {
if (!_init_graphics_pipeline(self, s->equirect2_vert, s->equirect2_frag,
true, &self->pipeline_equirect2)) {
return false;
}
@ -696,7 +696,7 @@ comp_layer_renderer_destroy(struct comp_layer_renderer *self)
NULL);
vk->vkDestroyPipeline(vk->device, self->pipeline_unpremultiplied_alpha,
NULL);
vk->vkDestroyPipeline(vk->device, self->pipeline_equirect, NULL);
vk->vkDestroyPipeline(vk->device, self->pipeline_equirect2, NULL);
for (uint32_t i = 0; i < ARRAY_SIZE(self->shader_modules); i++)
vk->vkDestroyShaderModule(vk->device, self->shader_modules[i],

2
src/xrt/compositor/main/comp_layer_renderer.h
View file

@ -39,7 +39,7 @@ struct comp_layer_renderer
VkShaderModule shader_modules[2];
VkPipeline pipeline_premultiplied_alpha;
VkPipeline pipeline_unpremultiplied_alpha;
VkPipeline pipeline_equirect;
VkPipeline pipeline_equirect2;
VkDescriptorSetLayout descriptor_set_layout;
VkDescriptorSetLayout descriptor_set_layout_equirect;

23
src/xrt/compositor/main/comp_renderer.c
View file

@ -575,21 +575,21 @@ comp_renderer_set_projection_layer(struct comp_renderer *r,
}
void
comp_renderer_set_equirect_layer(struct comp_renderer *r,
uint32_t layer,
struct comp_swapchain_image *image,
struct xrt_layer_data *data)
comp_renderer_set_equirect2_layer(struct comp_renderer *r,
uint32_t layer,
struct comp_swapchain_image *image,
struct xrt_layer_data *data)
{
struct xrt_vec3 s = {1.0f, 1.0f, 1.0f};
struct xrt_matrix_4x4 model_matrix;
math_matrix_4x4_model(&data->equirect.pose, &s, &model_matrix);
math_matrix_4x4_model(&data->equirect2.pose, &s, &model_matrix);
comp_layer_set_flip_y(r->lr->layers[layer], data->flip_y);
struct comp_render_layer *l = r->lr->layers[layer];
l->type = XRT_LAYER_EQUIRECT;
l->visibility = data->equirect.visibility;
l->type = XRT_LAYER_EQUIRECT2;
l->visibility = data->equirect2.visibility;
l->flags = data->flags;
l->view_space =
(data->flags & XRT_LAYER_COMPOSITION_VIEW_SPACE_BIT) != 0;
@ -598,13 +598,14 @@ comp_renderer_set_equirect_layer(struct comp_renderer *r,
comp_layer_update_descriptors(
l, image->repeat_sampler,
get_image_view(image, data->flags, data->equirect.sub.array_index));
get_image_view(image, data->flags,
data->equirect2.sub.array_index));
comp_layer_update_equirect_descriptor(l, &data->equirect);
comp_layer_update_equirect2_descriptor(l, &data->equirect2);
for (uint32_t i = 0; i < 2; i++) {
l->transformation[i].offset = data->equirect.sub.rect.offset;
l->transformation[i].extent = data->equirect.sub.rect.extent;
l->transformation[i].offset = data->equirect2.sub.rect.offset;
l->transformation[i].extent = data->equirect2.sub.rect.extent;
}
}

8
src/xrt/compositor/main/comp_renderer.h
View file

@ -74,10 +74,10 @@ comp_renderer_set_cylinder_layer(struct comp_renderer *r,
struct xrt_layer_data *data);
void
comp_renderer_set_equirect_layer(struct comp_renderer *r,
uint32_t layer,
struct comp_swapchain_image *image,
struct xrt_layer_data *data);
comp_renderer_set_equirect2_layer(struct comp_renderer *r,
uint32_t layer,
struct comp_swapchain_image *image,
struct xrt_layer_data *data);
void
comp_renderer_allocate_layers(struct comp_renderer *self, uint32_t num_layers);

24
src/xrt/compositor/main/comp_shaders.c
View file

@ -22,8 +22,8 @@
#include "shaders/layer.frag.h"
#include "shaders/layer.vert.h"
#include "shaders/equirect.frag.h"
#include "shaders/equirect.vert.h"
#include "shaders/equirect2.frag.h"
#include "shaders/equirect2.vert.h"
#include "shaders/mesh.frag.h"
#include "shaders/mesh.vert.h"
@ -89,14 +89,14 @@ comp_shaders_load(struct vk_bundle *vk, struct comp_shaders *s)
sizeof(shaders_mesh_frag), // size
&s->mesh_frag)); // out
C(shader_load(vk, // vk_bundle
shaders_equirect_vert, // data
sizeof(shaders_equirect_vert), // size
&s->equirect_vert)); // out
C(shader_load(vk, // vk_bundle
shaders_equirect_frag, // data
sizeof(shaders_equirect_frag), // size
&s->equirect_frag)); // out
C(shader_load(vk, // vk_bundle
shaders_equirect2_vert, // data
sizeof(shaders_equirect2_vert), // size
&s->equirect2_vert)); // out
C(shader_load(vk, // vk_bundle
shaders_equirect2_frag, // data
sizeof(shaders_equirect2_frag), // size
&s->equirect2_frag)); // out
C(shader_load(vk, // vk_bundle
shaders_layer_vert, // data
@ -123,8 +123,8 @@ comp_shaders_close(struct vk_bundle *vk, struct comp_shaders *s)
{
D(mesh_vert);
D(mesh_frag);
D(equirect_vert);
D(equirect_frag);
D(equirect2_vert);
D(equirect2_frag);
D(layer_vert);
D(layer_frag);

0
src/xrt/compositor/shaders/equirect.frag → src/xrt/compositor/shaders/equirect2.frag
View file

0
src/xrt/compositor/shaders/equirect.vert → src/xrt/compositor/shaders/equirect2.vert
View file

4
src/xrt/compositor/shaders/meson.build
View file

@ -6,8 +6,8 @@ shader_srcs = [
'mesh.vert',
'layer.vert',
'layer.frag',
'equirect.vert',
'equirect.frag'
'equirect2.vert',
'equirect2.frag'
]
shader_headers = []

2
src/xrt/include/xrt/meson.build
View file

@ -98,7 +98,7 @@ if get_option('layer_equirect')
endif
if get_option('layer_equirect2')
have_conf.set('XRT_FEATURE_OPENXR_LAYER_EQUIRECT', true)
have_conf.set('XRT_FEATURE_OPENXR_LAYER_EQUIRECT2', true)
endif
xrt_config_have_h = configure_file(

30
src/xrt/include/xrt/xrt_compositor.h
View file

@ -96,7 +96,7 @@ enum xrt_layer_type
XRT_LAYER_QUAD,
XRT_LAYER_CUBE,
XRT_LAYER_CYLINDER,
XRT_LAYER_EQUIRECT,
XRT_LAYER_EQUIRECT2,
};
/*!
@ -250,12 +250,12 @@ struct xrt_layer_cylinder_data
};
/*!
* All the pure data values associated with a equirect layer.
* All the pure data values associated with a equirect2 layer.
*
* The @ref xrt_swapchain references and @ref xrt_device are provided outside of
* this struct.
*/
struct xrt_layer_equirect_data
struct xrt_layer_equirect2_data
{
enum xrt_layer_eye_visibility visibility;
@ -327,7 +327,7 @@ struct xrt_layer_data
struct xrt_layer_quad_data quad;
struct xrt_layer_cube_data cube;
struct xrt_layer_cylinder_data cylinder;
struct xrt_layer_equirect_data equirect;
struct xrt_layer_equirect2_data equirect2;
};
};
@ -723,17 +723,17 @@ struct xrt_compositor
const struct xrt_layer_data *data);
/*!
* Adds a equirect layer for submission.
* Adds a equirect2 layer for submission.
*
* @param xc Self pointer
* @param xdev The device the layer is relative to.
* @param xsc Swapchain.
* @param data All of the pure data bits.
*/
xrt_result_t (*layer_equirect)(struct xrt_compositor *xc,
struct xrt_device *xdev,
struct xrt_swapchain *xsc,
const struct xrt_layer_data *data);
xrt_result_t (*layer_equirect2)(struct xrt_compositor *xc,
struct xrt_device *xdev,
struct xrt_swapchain *xsc,
const struct xrt_layer_data *data);
/*!
* Commits all of the submitted layers, it's from this on that the
@ -982,19 +982,19 @@ xrt_comp_layer_cylinder(struct xrt_compositor *xc,
}
/*!
* @copydoc xrt_compositor::layer_equirect
* @copydoc xrt_compositor::layer_equirect2
*
* Helper for calling through the function pointer.
*
* @public @memberof xrt_compositor
*/
static inline xrt_result_t
xrt_comp_layer_equirect(struct xrt_compositor *xc,
struct xrt_device *xdev,
struct xrt_swapchain *xsc,
const struct xrt_layer_data *data)
xrt_comp_layer_equirect2(struct xrt_compositor *xc,
struct xrt_device *xdev,
struct xrt_swapchain *xsc,
const struct xrt_layer_data *data)
{
return xc->layer_equirect(xc, xdev, xsc, data);
return xc->layer_equirect2(xc, xdev, xsc, data);
}
/*!

2
src/xrt/include/xrt/xrt_config_build.h.cmake_in
View file

@ -21,6 +21,6 @@
#cmakedefine XRT_FEATURE_OPENXR_LAYER_DEPTH
#cmakedefine XRT_FEATURE_OPENXR_LAYER_EQUIRECT
#cmakedefine XRT_FEATURE_OPENXR_LAYER_EQUIRECT2
#cmakedefine XRT_FEATURE_OPENXR_LAYER_EQUIRECT_LEGACY

12
src/xrt/ipc/client/ipc_client_compositor.c
View file

@ -592,12 +592,12 @@ ipc_compositor_layer_cylinder(struct xrt_compositor *xc,
}
static xrt_result_t
ipc_compositor_layer_equirect(struct xrt_compositor *xc,
struct xrt_device *xdev,
struct xrt_swapchain *xsc,
const struct xrt_layer_data *data)
ipc_compositor_layer_equirect2(struct xrt_compositor *xc,
struct xrt_device *xdev,
struct xrt_swapchain *xsc,
const struct xrt_layer_data *data)
{
return handle_layer(xc, xdev, xsc, data, XRT_LAYER_EQUIRECT);
return handle_layer(xc, xdev, xsc, data, XRT_LAYER_EQUIRECT2);
}
static xrt_result_t
@ -785,7 +785,7 @@ ipc_client_compositor_create(struct ipc_connection *ipc_c,
c->base.base.layer_quad = ipc_compositor_layer_quad;
c->base.base.layer_cube = ipc_compositor_layer_cube;
c->base.base.layer_cylinder = ipc_compositor_layer_cylinder;
c->base.base.layer_equirect = ipc_compositor_layer_equirect;
c->base.base.layer_equirect2 = ipc_compositor_layer_equirect2;
c->base.base.layer_commit = ipc_compositor_layer_commit;
c->base.base.destroy = ipc_compositor_destroy;
c->base.base.poll_events = ipc_compositor_poll_events;

2
src/xrt/ipc/server/ipc_server_per_client_thread.c
View file

@ -164,7 +164,7 @@ client_loop(volatile struct ipc_client_state *ics)
rl->data.quad.sub.image_index = 0;
rl->data.cube.sub.image_index = 0;
rl->data.cylinder.sub.image_index = 0;
rl->data.equirect.sub.image_index = 0;
rl->data.equirect2.sub.image_index = 0;
//! @todo set rects or array index?
}

18
src/xrt/ipc/server/ipc_server_process.c
View file

@ -869,20 +869,20 @@ _update_cylinder_layer(struct xrt_compositor *xc,
}
static bool
_update_equirect_layer(struct xrt_compositor *xc,
volatile struct ipc_client_state *ics,
volatile struct ipc_layer_entry *layer,
uint32_t i)
_update_equirect2_layer(struct xrt_compositor *xc,
volatile struct ipc_client_state *ics,
volatile struct ipc_layer_entry *layer,
uint32_t i)
{
struct xrt_device *xdev;
struct xrt_swapchain *xcs;
struct xrt_layer_data *data;
if (!do_single(xc, ics, layer, i, "equirect", &xdev, &xcs, &data)) {
if (!do_single(xc, ics, layer, i, "equirect2", &xdev, &xcs, &data)) {
return false;
}
xrt_comp_layer_equirect(xc, xdev, xcs, data);
xrt_comp_layer_equirect2(xc, xdev, xcs, data);
return true;
}
@ -974,9 +974,9 @@ _update_layers(struct ipc_server *s, struct xrt_compositor *xc)
return false;
}
break;
case XRT_LAYER_EQUIRECT:
if (!_update_equirect_layer(xc, ics, layer,
i)) {
case XRT_LAYER_EQUIRECT2:
if (!_update_equirect2_layer(xc, ics, layer,
i)) {
return false;
}
break;

2
src/xrt/state_trackers/oxr/oxr_extension_support.h
View file

@ -136,7 +136,7 @@
* XR_KHR_composition_layer_equirect2
*/
#if defined(XR_KHR_composition_layer_equirect2) && \
defined(XRT_FEATURE_OPENXR_LAYER_EQUIRECT)
defined(XRT_FEATURE_OPENXR_LAYER_EQUIRECT2)
#define OXR_HAVE_KHR_composition_layer_equirect2
#define OXR_EXTENSION_SUPPORT_KHR_composition_layer_equirect2(_) \
_(KHR_composition_layer_equirect2, KHR_COMPOSITION_LAYER_EQUIRECT2)

4
src/xrt/state_trackers/oxr/oxr_instance.c
View file

@ -353,8 +353,8 @@ oxr_instance_create(struct oxr_logger *log,
CHECK_LAYER_TYPE("projection layers with depth images",
layer_stereo_projection_depth);
#endif
#ifdef XRT_FEATURE_OPENXR_LAYER_EQUIRECT
CHECK_LAYER_TYPE("equirect layers", layer_equirect);
#ifdef XRT_FEATURE_OPENXR_LAYER_EQUIRECT2
CHECK_LAYER_TYPE("equirect2 layers", layer_equirect2);
#endif
#undef CHECK_LAYER_TYPE
}

26
src/xrt/state_trackers/oxr/oxr_session.c
View file

@ -1224,7 +1224,7 @@ verify_equirect_layer(struct xrt_compositor *xc,
struct xrt_device *head,
uint64_t timestamp)
{
#ifndef XRT_FEATURE_OPENXR_LAYER_EQUIRECT
#ifndef XRT_FEATURE_OPENXR_LAYER_EQUIRECT2
return oxr_error(log, XR_ERROR_LAYER_INVALID,
"(frameEndInfo->layers[%u]->type) layer type "
"XrCompositionLayerEquirectKHR not supported",
@ -1329,7 +1329,7 @@ verify_equirect2_layer(struct xrt_compositor *xc,
struct xrt_device *head,
uint64_t timestamp)
{
#ifndef XRT_FEATURE_OPENXR_LAYER_EQUIRECT
#ifndef XRT_FEATURE_OPENXR_LAYER_EQUIRECT2
return oxr_error(log, XR_ERROR_LAYER_INVALID,
"(frameEndInfo->layers[%u]->type) layer type "
"XrCompositionLayerEquirect2KHR not supported",
@ -1851,7 +1851,7 @@ submit_equirect2_layer(struct oxr_session *sess,
struct xrt_layer_data data;
U_ZERO(&data);
data.type = XRT_LAYER_EQUIRECT;
data.type = XRT_LAYER_EQUIRECT2;
data.name = XRT_INPUT_GENERIC_HEAD_POSE;
data.timestamp = timestamp;
data.flags = flags;
@ -1859,20 +1859,20 @@ submit_equirect2_layer(struct oxr_session *sess,
struct xrt_rect *rect =
(struct xrt_rect *)&equirect->subImage.imageRect;
data.equirect.visibility =
data.equirect2.visibility =
convert_eye_visibility(equirect->eyeVisibility);
data.equirect.sub.image_index = sc->released.index;
data.equirect.sub.array_index = equirect->subImage.imageArrayIndex;
data.equirect.sub.rect = *rect;
data.equirect.pose = pose;
data.equirect2.sub.image_index = sc->released.index;
data.equirect2.sub.array_index = equirect->subImage.imageArrayIndex;
data.equirect2.sub.rect = *rect;
data.equirect2.pose = pose;
data.equirect.radius = equirect->radius;
data.equirect.central_horizontal_angle =
data.equirect2.radius = equirect->radius;
data.equirect2.central_horizontal_angle =
equirect->centralHorizontalAngle;
data.equirect.upper_vertical_angle = equirect->upperVerticalAngle;
data.equirect.lower_vertical_angle = equirect->lowerVerticalAngle;
data.equirect2.upper_vertical_angle = equirect->upperVerticalAngle;
data.equirect2.lower_vertical_angle = equirect->lowerVerticalAngle;
CALL_CHK(xrt_comp_layer_equirect(xc, head, sc->swapchain, &data));
CALL_CHK(xrt_comp_layer_equirect2(xc, head, sc->swapchain, &data));
return XR_SUCCESS;
}