shadowcat/iris
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

layers initial impl (no sensors)

Browse Source
This commit is contained in:
Shadow Cat
2025-09-20 00:50:58 -04:00
parent 7651699743
commit 8ecd8bb171
7 changed files with 312 additions and 198 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
src/render/mod.rs
View File

@@ -3,6 +3,7 @@ use std::num::NonZero;
use crate::{
layout::Ui,
render::{data::PrimitiveInstance, texture::GpuTextures, util::ArrBuf},
util::HashMap,
};
use data::WindowUniform;
use wgpu::{
@@ -23,38 +24,76 @@ const SHAPE_SHADER: &str = include_str!("./shader.wgsl");
pub struct UiRenderer {
uniform_group: BindGroup,
primitive_layout: BindGroupLayout,
primitive_group: BindGroup,
rsc_layout: BindGroupLayout,
rsc_group: BindGroup,
pipeline: RenderPipeline,
layers: HashMap<usize, RenderLayer>,
active: Vec<usize>,
window_buffer: Buffer,
textures: GpuTextures,
}
struct RenderLayer {
instance: ArrBuf<PrimitiveInstance>,
primitives: PrimitiveBuffers,
textures: GpuTextures,
primitive_group: BindGroup,
}
impl UiRenderer {
pub fn draw<'a>(&'a self, pass: &mut RenderPass<'a>) {
if self.instance.len() == 0 {
return;
}
pass.set_pipeline(&self.pipeline);
pass.set_bind_group(0, &self.uniform_group, &[]);
pass.set_bind_group(1, &self.primitive_group, &[]);
pass.set_bind_group(2, &self.rsc_group, &[]);
pass.set_vertex_buffer(0, self.instance.buffer.slice(..));
pass.draw(0..4, 0..self.instance.len() as u32);
for i in &self.active {
let layer = &self.layers[i];
if layer.instance.len() == 0 {
continue;
}
pass.set_bind_group(1, &layer.primitive_group, &[]);
pass.set_vertex_buffer(0, layer.instance.buffer.slice(..));
pass.draw(0..4, 0..layer.instance.len() as u32);
}
}
pub fn update<Ctx>(&mut self, device: &Device, queue: &Queue, ui: &mut Ui<Ctx>) {
if ui.primitives.updated {
self.instance
.update(device, queue, ui.primitives.instances());
self.primitives.update(device, queue, ui.primitives.data());
self.primitive_group =
Self::primitive_group(device, &self.primitive_layout, self.primitives.buffers())
self.active.clear();
for (i, primitives) in ui.layers.iter_mut() {
self.active.push(i);
for change in primitives.apply_free() {
if let Some(inst) = ui.active.widgets.get_mut(&change.id) {
for h in &mut inst.primitives {
if h.inst_idx == change.old {
h.inst_idx = change.new;
break;
}
}
}
}
let layer = self.layers.entry(i).or_insert_with(|| {
let primitives = PrimitiveBuffers::new(device);
let primitive_group =
Self::primitive_group(device, &self.primitive_layout, primitives.buffers());
RenderLayer {
instance: ArrBuf::new(
device,
BufferUsages::VERTEX | BufferUsages::COPY_DST,
"instance",
),
primitives,
primitive_group,
}
});
if primitives.updated {
layer.instance.update(device, queue, primitives.instances());
layer.primitives.update(device, queue, primitives.data());
layer.primitive_group = Self::primitive_group(
device,
&self.primitive_layout,
layer.primitives.buffers(),
)
}
}
if self.textures.update(&mut ui.textures) {
self.rsc_group = Self::rsc_group(device, &self.rsc_layout, &self.textures)
@@ -87,13 +126,6 @@ impl UiRenderer {
usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
});
let instance = ArrBuf::new(
device,
BufferUsages::VERTEX | BufferUsages::COPY_DST,
"instance",
);
let primitives = PrimitiveBuffers::new(device);
let uniform_layout = device.create_bind_group_layout(&BindGroupLayoutDescriptor {
entries: &[BindGroupLayoutEntry {
binding: 0,
@@ -126,9 +158,6 @@ impl UiRenderer {
label: Some("primitive"),
});
let primitive_group =
Self::primitive_group(device, &primitive_layout, primitives.buffers());
let tex_manager = GpuTextures::new(device, queue);
let rsc_layout = Self::rsc_layout(device, &limits);
let rsc_group = Self::rsc_group(device, &rsc_layout, &tex_manager);
@@ -179,13 +208,12 @@ impl UiRenderer {
Self {
uniform_group,
primitive_layout,
primitive_group,
rsc_layout,
rsc_group,
pipeline,
window_buffer,
instance,
primitives,
layers: HashMap::default(),
active: Vec::new(),
textures: tex_manager,
}
}

148
src/render/primitive.rs
View File

@@ -1,4 +1,4 @@
use std::ops::{Deref, DerefMut, Range};
use std::ops::{Deref, DerefMut};
use crate::{
layout::{Color, UiRegion},
@@ -8,30 +8,22 @@ use crate::{
use bytemuck::Pod;
use wgpu::*;
#[derive(Default)]
struct Instances {
data: Vec<PrimitiveInstance>,
assoc: Vec<Id>,
}
pub struct Primitives {
instances: Instances,
run: Instances,
pos: usize,
instances: Vec<PrimitiveInstance>,
assoc: Vec<Id>,
data: PrimitiveData,
free: Vec<usize>,
pub updated: bool,
run_start: usize,
}
impl Default for Primitives {
fn default() -> Self {
Self {
instances: Default::default(),
run: Default::default(),
pos: 0,
assoc: Default::default(),
data: Default::default(),
free: Vec::new(),
updated: true,
run_start: 0,
}
}
}
@@ -104,7 +96,13 @@ macro_rules! primitives {
}
impl Primitives {
pub fn write<P: Primitive>(&mut self, id: Id, data: P, region: UiRegion) -> PrimitiveHandle {
pub fn write<P: Primitive>(
&mut self,
layer: usize,
id: Id,
data: P,
region: UiRegion,
) -> PrimitiveHandle {
let vec = P::vec(&mut self.data);
let i = vec.add(data);
let inst = PrimitiveInstance {
@@ -112,69 +110,37 @@ impl Primitives {
idx: i as u32,
binding: P::BINDING,
};
if self.running() {
self.run.push(id, inst);
} else if self.instances.assoc.get(self.pos).is_some_and(|i| *i == id) {
self.instances.data[self.pos] = inst;
let inst_i = if let Some(i) = self.free.pop() {
self.instances[i] = inst;
self.assoc[i] = id;
i
} else {
self.run_start = self.pos;
self.run.push(id, inst);
}
self.pos += 1;
PrimitiveHandle::new::<P>(i)
let i = self.instances.len();
self.instances.push(inst);
self.assoc.push(id);
i
};
PrimitiveHandle::new::<P>(layer, inst_i, i)
}
fn running(&self) -> bool {
self.run.len() != 0
}
pub fn skip(&mut self, range: &mut Range<usize>) {
if self.running() {
self.run.data.extend(&self.instances.data[range.clone()]);
self.run.assoc.extend(
self.instances.assoc[range.clone()]
.iter()
.map(|i| i.duplicate()),
);
}
range.start = self.pos;
self.pos += range.len();
range.end = self.pos;
}
pub(crate) fn clear(&mut self) {
self.updated = true;
self.instances.clear();
self.run.clear();
self.data.clear();
self.pos = 0;
}
pub fn apply(&mut self, span: Range<usize>) -> isize {
let delta = self.pos as isize - span.end as isize;
if self.run.len() == 0 {
self.run_start = self.pos;
}
let span = self.run_start..span.end;
self.instances.splice(span, &mut self.run);
delta
}
pub fn set_pos(&mut self, p: usize) {
self.pos = p;
/// returns (old index, new index)
pub fn apply_free(&mut self) -> impl Iterator<Item = PrimitiveChange> {
self.free.sort_by(|a, b| b.cmp(a));
self.free.drain(..).filter_map(|i| {
self.instances.swap_remove(i);
self.assoc.swap_remove(i);
if i == self.instances.len() {
return None;
}
let id = self.assoc[i].duplicate();
let old = self.instances.len();
Some(PrimitiveChange { id, old, new: i })
})
}
pub fn free(&mut self, h: &PrimitiveHandle) {
self.data.free(h.binding, h.idx);
}
pub fn replace(&mut self) {
std::mem::swap(&mut self.run, &mut self.instances);
self.run.clear();
}
pub fn cur_pos(&self) -> usize {
self.pos
self.data.free(h.binding, h.data_idx);
self.free.push(h.inst_idx);
}
pub fn data(&self) -> &PrimitiveData {
@@ -182,20 +148,30 @@ impl Primitives {
}
pub fn instances(&self) -> &Vec<PrimitiveInstance> {
&self.instances.data
&self.instances
}
}
pub struct PrimitiveChange {
pub id: Id,
pub old: usize,
pub new: usize,
}
#[derive(Debug)]
pub struct PrimitiveHandle {
idx: usize,
binding: u32,
pub layer: usize,
pub inst_idx: usize,
pub data_idx: usize,
pub binding: u32,
}
impl PrimitiveHandle {
fn new<P: Primitive>(idx: usize) -> Self {
fn new<P: Primitive>(layer: usize, inst_idx: usize, data_idx: usize) -> Self {
Self {
idx,
layer,
inst_idx,
data_idx,
binding: P::BINDING,
}
}
@@ -283,21 +259,3 @@ impl<T> DerefMut for PrimitiveVec<T> {
&mut self.vec
}
}
impl Instances {
pub fn clear(&mut self) {
self.data.clear();
self.assoc.clear();
}
pub fn len(&self) -> usize {
self.data.len()
}
pub fn push(&mut self, id: Id, inst: PrimitiveInstance) {
self.assoc.push(id);
self.data.push(inst);
}
pub fn splice(&mut self, span: Range<usize>, other: &mut Instances) {
self.data.splice(span.clone(), other.data.drain(..));
self.assoc.splice(span, other.assoc.drain(..));
}
}