pub opacity: Option<f32>,

pub pending_iconify: bool,

pub pending_restore: bool,

pub pending_maximize: bool,

pub pending_focus: bool,

fn window_handle(&self) -> core::result::Result<WindowHandle<'_>, HandleError> {

// SAFETY:

// - Handles passed from Java are valid

Ok(unsafe { WindowHandle::borrow_raw(self.window_handle) })

}

fn display_handle(&self) -> core::result::Result<DisplayHandle<'_>, HandleError> {

// SAFETY:

// - Handles passed from Java are valid

Ok(unsafe { DisplayHandle::borrow_raw(self.display_handle) })

}

commands: &mut Commands,

raw_window_handle: RawWindowHandle,

raw_display_handle: RawDisplayHandle,

width: u32,

height: u32,

scale_factor: f32,

transparent: bool,

) -> Result<Entity> {

let glfw_window = GlfwWindow {

window_handle: raw_window_handle,

display_handle: raw_display_handle,

};

let window_wrapper = WindowWrapper::new(glfw_window);

let handle_wrapper = RawHandleWrapper::new(&window_wrapper)?;

let physical_width = (width as f32 * scale_factor) as u32;

let physical_height = (height as f32 * scale_factor) as u32;

// Window transparency is an explicit opt-in (default opaque). When requested,

// pick the swapchain composite mode the platform expects.

// TODO: dxgi swapchain for windows https://github.com/gfx-rs/wgpu/issues/3486

let (transparent, composite_alpha_mode) = if transparent {

match &raw_window_handle {

RawWindowHandle::AppKit(_) => (true, CompositeAlphaMode::PostMultiplied),

RawWindowHandle::Wayland(_) => (true, CompositeAlphaMode::PreMultiplied),

_ => (true, CompositeAlphaMode::Auto),

}

} else {

(false, CompositeAlphaMode::Opaque)

};

Ok(commands

.spawn((

Window {

resolution: WindowResolution::new(physical_width, physical_height)

.with_scale_factor_override(scale_factor),

transparent,

composite_alpha_mode,

..default()

},

handle_wrapper,

Surface,

WindowControls::default(),

))

.id())

In((window_handle, width, height, scale_factor, transparent)): In<(u64, u32, u32, f32, bool)>,

mut commands: Commands,

) -> Result<Entity> {

use raw_window_handle::{AppKitDisplayHandle, AppKitWindowHandle};

// GLFW gives us NSWindow*, but AppKitWindowHandle needs NSView*

// so we have to do some objc magic to grab the right pointer

let ns_view_ptr = {

use objc2::rc::Retained;

use objc2_app_kit::{NSView, NSWindow};

// SAFETY:

// - window_handle is a valid NSWindow pointer from the GLFW window

let ns_window = window_handle as *mut NSWindow;

if ns_window.is_null() {

return Err(error::ProcessingError::InvalidWindowHandle);

}

// SAFETY:

// - The contentView is owned by NSWindow and remains valid as long as the window exists

let ns_window_ref = unsafe { &*ns_window };

let content_view: Option<Retained<NSView>> = ns_window_ref.contentView();

match content_view {

Some(view) => Retained::as_ptr(&view) as *mut std::ffi::c_void,

None => {

return Err(error::ProcessingError::InvalidWindowHandle);

}

}

};

let window = AppKitWindowHandle::new(NonNull::new(ns_view_ptr).unwrap());

let display = AppKitDisplayHandle::new();

spawn_surface(

&mut commands,

RawWindowHandle::AppKit(window),

RawDisplayHandle::AppKit(display),

width,

height,

scale_factor,

transparent,

)

In((window_handle, width, height, scale_factor, transparent)): In<(u64, u32, u32, f32, bool)>,

mut commands: Commands,

) -> Result<Entity> {

use std::num::NonZeroIsize;

use raw_window_handle::{Win32WindowHandle, WindowsDisplayHandle};

use windows::Win32::System::LibraryLoader::GetModuleHandleW;

if window_handle == 0 {

return Err(error::ProcessingError::InvalidWindowHandle);

}

// HWND is isize, so cast it

let hwnd_isize = window_handle as isize;

let hwnd_nonzero = match NonZeroIsize::new(hwnd_isize) {

Some(nz) => nz,

None => return Err(error::ProcessingError::InvalidWindowHandle),

};

let mut window = Win32WindowHandle::new(hwnd_nonzero);

// VK_KHR_win32_surface requires hinstance *and* hwnd

// SAFETY: GetModuleHandleW(NULL) is safe

let hinstance = unsafe { GetModuleHandleW(None) }

.map_err(|_| error::ProcessingError::InvalidWindowHandle)?;

let hinstance_nonzero = NonZeroIsize::new(hinstance.0 as isize)

.ok_or(error::ProcessingError::InvalidWindowHandle)?;

window.hinstance = Some(hinstance_nonzero);

let display = WindowsDisplayHandle::new();

spawn_surface(

&mut commands,

RawWindowHandle::Win32(window),

RawDisplayHandle::Windows(display),

width,

height,

scale_factor,

transparent,

)

In((window_handle, display_handle, width, height, scale_factor, transparent)): In<(

u64,

u64,

u32,

u32,

f32,

bool,

)>,

mut commands: Commands,

) -> Result<Entity> {

use raw_window_handle::{WaylandDisplayHandle, WaylandWindowHandle};

if window_handle == 0 {

return Err(error::ProcessingError::HandleError(

HandleError::Unavailable,

));

}

let window_handle_ptr = NonNull::new(window_handle as *mut std::ffi::c_void).unwrap();

let window = WaylandWindowHandle::new(window_handle_ptr);

if display_handle == 0 {

return Err(error::ProcessingError::HandleError(

HandleError::Unavailable,

));

}

let display_handle_ptr = NonNull::new(display_handle as *mut std::ffi::c_void).unwrap();

let display = WaylandDisplayHandle::new(display_handle_ptr);

spawn_surface(

&mut commands,

RawWindowHandle::Wayland(window),

RawDisplayHandle::Wayland(display),

width,

height,

scale_factor,

transparent,

)

In((window_handle, display_handle, width, height, scale_factor, transparent)): In<(

u64,

u64,

u32,

u32,

f32,

bool,

)>,

mut commands: Commands,

) -> Result<Entity> {

use raw_window_handle::{XlibDisplayHandle, XlibWindowHandle};

if window_handle == 0 {

return Err(error::ProcessingError::HandleError(

HandleError::Unavailable,

));

}

// X11 Window is a u32/u64 ID, not a pointer

let window = XlibWindowHandle::new(window_handle as std::ffi::c_ulong);

if display_handle == 0 {

return Err(error::ProcessingError::HandleError(

HandleError::Unavailable,

));

}

let display_ptr = NonNull::new(display_handle as *mut std::ffi::c_void).unwrap();

let display = XlibDisplayHandle::new(Some(display_ptr), 0); // screen 0

spawn_surface(

&mut commands,

RawWindowHandle::Xlib(window),

RawDisplayHandle::Xlib(display),

width,

height,

scale_factor,

transparent,

)

In((window_handle, width, height, scale_factor, transparent)): In<(u64, u32, u32, f32, bool)>,

mut commands: Commands,

) -> Result<Entity> {

use raw_window_handle::{WebCanvasWindowHandle, WebDisplayHandle};

// For WASM, window_handle is a pointer to an HtmlCanvasElement

if window_handle == 0 {

return Err(error::ProcessingError::InvalidWindowHandle);

}

let canvas_ptr = NonNull::new(window_handle as *mut std::ffi::c_void).unwrap();

let window = WebCanvasWindowHandle::new(canvas_ptr.cast());

let display = WebDisplayHandle::new();

spawn_surface(

&mut commands,

RawWindowHandle::WebCanvas(window),

RawDisplayHandle::Web(display),

width,

height,

scale_factor,

transparent,

)

width: u32,

height: u32,

scale_factor: f32,

texture_format: TextureFormat,

) -> Result<(Extent3d, Vec<u8>, TextureFormat)> {

let size = Extent3d {

width: (width as f32 * scale_factor) as u32,

height: (height as f32 * scale_factor) as u32,

depth_or_array_layers: 1,

};

let pixel_size = match texture_format {

TextureFormat::R8Unorm => 1,

TextureFormat::Rg8Unorm => 2,

TextureFormat::Rgba8Unorm | TextureFormat::Rgba8UnormSrgb | TextureFormat::Bgra8Unorm => 4,

TextureFormat::Rgba16Float => 8,

TextureFormat::Rgba32Float => 16,

_ => return Err(ProcessingError::UnsupportedTextureFormat),

};

let data = vec![0u8; (size.width * size.height * pixel_size) as usize];

Ok((size, data, texture_format))

In(surface_entity): In<Entity>,

mut commands: Commands,

p_images: Query<&Image, With<Surface>>,

mut images: ResMut<Assets<bevy::image::Image>>,

) -> Result<()> {

match p_images.get(surface_entity) {

Ok(p_image) => {

images.remove(&p_image.handle);

commands.entity(surface_entity).despawn();

Ok(())

}

Err(QueryEntityError::QueryDoesNotMatch(..)) => {

commands.entity(surface_entity).despawn();

Ok(())

}

Err(_) => Err(ProcessingError::SurfaceNotFound),

}

In((window_entity, width, height)): In<(Entity, u32, u32)>,

mut windows: Query<&mut Window>,

mut graphics_query: Query<(&RenderTarget, &mut SurfaceSize)>,

) -> Result<()> {

let width = width.max(1);

let height = height.max(1);

if let Ok(mut window) = windows.get_mut(window_entity) {

let scale = window.resolution.scale_factor();

let physical_w = (width as f32 * scale) as u32;

let physical_h = (height as f32 * scale) as u32;

window

.resolution

.set_physical_resolution(physical_w, physical_h);

}

// SurfaceSize changes on resize, if not handled will break APIs dependent on correct SurfaceSize

for (target, mut surface_size) in graphics_query.iter_mut() {

if let RenderTarget::Window(WindowRef::Entity(surface)) = *target

&& surface == window_entity

{

*surface_size = SurfaceSize(width, height);

}

}

Ok(())

In((window_entity, density)): In<(Entity, f32)>,

mut windows: Query<&mut Window>,

) -> Result<()> {

if let Ok(mut window) = windows.get_mut(window_entity) {

let logical_w = window.resolution.width();

let logical_h = window.resolution.height();

window.resolution.set_scale_factor_override(Some(density));

window

.resolution

.set_physical_resolution((logical_w * density) as u32, (logical_h * density) as u32);

Ok(())

} else {

Err(error::ProcessingError::SurfaceNotFound)

}

query

.get(entity)

.map(|w| w.resolution.scale_factor())

.unwrap_or(1.0)

query

.get(entity)

.map(|w| w.resolution.physical_width())

.unwrap_or(0)

query

.get(entity)

.map(|w| w.resolution.physical_height())

.unwrap_or(0)

query

.get(entity)

.map(|w| w.resolution.width() as u32)

.unwrap_or(0)

query

.get(entity)

.map(|w| w.resolution.height() as u32)

.unwrap_or(0)

In((entity, title)): In<(Entity, String)>,

mut windows: Query<&mut Window>,

) -> Result<()> {

if let Ok(mut window) = windows.get_mut(entity) {

window.title = title;

}

Ok(())

match windows.get(entity).map(|w| w.position) {

Ok(WindowPosition::At(p)) => p,

_ => IVec2::ZERO,

}

In((entity, x, y)): In<(Entity, i32, i32)>,

mut windows: Query<&mut Window>,

) -> Result<()> {

if let Ok(mut window) = windows.get_mut(entity) {

window.position = WindowPosition::At(IVec2::new(x, y));

}

Ok(())

In((entity, visible)): In<(Entity, bool)>,

mut windows: Query<&mut Window>,

) -> Result<()> {

if let Ok(mut window) = windows.get_mut(entity) {

window.visible = visible;

}

Ok(())

In((entity, resizable)): In<(Entity, bool)>,

mut windows: Query<&mut Window>,

) -> Result<()> {

if let Ok(mut window) = windows.get_mut(entity) {

window.resizable = resizable;

}

Ok(())

In((entity, decorated)): In<(Entity, bool)>,

mut windows: Query<&mut Window>,

) -> Result<()> {

if let Ok(mut window) = windows.get_mut(entity) {

window.decorations = decorated;

}

Ok(())

In((entity, level)): In<(Entity, WindowLevel)>,

mut windows: Query<&mut Window>,

) -> Result<()> {

if let Ok(mut window) = windows.get_mut(entity) {

window.window_level = level;

}

Ok(())

In((entity, mode)): In<(Entity, WindowMode)>,

mut windows: Query<&mut Window>,

) -> Result<()> {

if let Ok(mut window) = windows.get_mut(entity) {

window.mode = mode;

}

Ok(())

In((entity, opacity)): In<(Entity, f32)>,

mut controls: Query<&mut WindowControls>,

) -> Result<()> {

if let Ok(mut controls) = controls.get_mut(entity) {

controls.opacity = Some(opacity.clamp(0.0, 1.0));

}

Ok(())

if let Ok(mut controls) = controls.get_mut(entity) {

controls.pending_iconify = true;

}

Ok(())

if let Ok(mut controls) = controls.get_mut(entity) {

controls.pending_restore = true;

}

Ok(())

if let Ok(mut controls) = controls.get_mut(entity) {

controls.pending_maximize = true;

}

Ok(())

if let Ok(mut controls) = controls.get_mut(entity) {

controls.pending_focus = true;

}

Ok(())

monitors

.get(entity)

.map(|m| m.physical_position)

.unwrap_or(IVec2::ZERO)

In(entity): In<Entity>,

monitors: Query<(&Monitor, Option<&MonitorWorkarea>)>,

) -> IRect {

match monitors.get(entity) {

Ok((_, Some(workarea))) => workarea.0,

Ok((monitor, None)) => IRect::from_corners(

monitor.physical_position,

monitor.physical_position

+ IVec2::new(

monitor.physical_width as i32,

monitor.physical_height as i32,

),

),

Err(_) => IRect::from_corners(IVec2::ZERO, IVec2::ZERO),

}

In((surface, monitor, x, y)): In<(Entity, Entity, i32, i32)>,

mut windows: Query<&mut Window>,

monitors: Query<(&Monitor, Option<&MonitorWorkarea>)>,

) -> Result<()> {

let Ok(mut window) = windows.get_mut(surface) else {

return Ok(());

};

let origin = match monitors.get(monitor) {

Ok((_, Some(workarea))) => workarea.0.min,

Ok((monitor, None)) => monitor.physical_position,

Err(_) => return Ok(()),

};

window.position = WindowPosition::At(origin + IVec2::new(x, y));

Ok(())

In((surface, monitor)): In<(Entity, Entity)>,

mut windows: Query<&mut Window>,

monitors: Query<(&Monitor, Option<&MonitorWorkarea>)>,

) -> Result<()> {

let Ok(mut window) = windows.get_mut(surface) else {

return Ok(());

};

let area = match monitors.get(monitor) {

Ok((_, Some(workarea))) => workarea.0,

Ok((monitor, None)) => IRect::from_corners(

monitor.physical_position,

monitor.physical_position

+ IVec2::new(

monitor.physical_width as i32,

monitor.physical_height as i32,

),

),

Err(_) => return Ok(()),

};

let size = IVec2::new(

window.resolution.physical_width() as i32,

window.resolution.physical_height() as i32,

);

window.position = WindowPosition::At(area.min + (area.size() - size) / 2);

Ok(())