refactor(all): remove levels and render

1 files changed, 335 insertions, 0 deletions

diff --git a/examples/render-quad/src/draw_pass.rs b/examples/render-quad/src/draw_pass.rs
new file mode 100644
index 0000000..9b32fcb
--- /dev/null
+++ b/examples/render-quad/src/draw_pass.rs
@@ -0,0 +1,335 @@
+//! Minimal code for drawing any level, based on traits from stockton-levels
+
+use anyhow::{Context, Result};
+use hal::{
+    buffer::SubRange,
+    command::{ClearColor, ClearValue, RenderAttachmentInfo, SubpassContents},
+    format::Format,
+    image::Layout,
+    pass::Attachment,
+    pso::{
+        BlendDesc, BlendOp, BlendState, ColorBlendDesc, ColorMask, DepthStencilDesc, Face, Factor,
+        FrontFace, InputAssemblerDesc, LogicOp, PolygonMode, Primitive, Rasterizer, State,
+        VertexInputRate,
+    },
+};
+use legion::{Entity, IntoQuery};
+use std::{
+    array::IntoIter,
+    iter::{empty, once},
+};
+use stockton_skeleton::{
+    buffers::draw::DrawBuffers,
+    builders::{
+        AttachmentSpec, CompletePipeline, PipelineSpecBuilder, RenderpassSpec, ShaderDesc,
+        ShaderKind, VertexBufferSpec, VertexPrimitiveAssemblerSpec,
+    },
+    draw_passes::util::TargetSpecificResources,
+    mem::{DataPool, StagingPool},
+    queue_negotiator::QueueFamilyNegotiator,
+    types::*,
+    DrawPass, IntoDrawPass, PassPosition, RenderingContext, Session,
+};
+
+use crate::ExampleState;
+
+/// The vertices that go to the shader (XY + RGB)
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+struct Vertex(pub Vector2, pub Vector3);
+
+/// An example draw pass
+pub struct ExampleDrawPass<'a> {
+    /// Index and vertex buffer pair
+    draw_buffers: DrawBuffers<'a, Vertex, DataPool, StagingPool>,
+
+    /// Resources that depend on the surface. This is seperate so that we can deal with surface changes more easily.
+    surface_resources: SurfaceDependentResources,
+
+    /// Entity we get our state from
+    state_ent: Entity,
+}
+
+/// Config for our draw pass. This is turned into our drawpass using [`IntoDrawPass`]
+pub struct ExampleDrawPassConfig {
+    pub state_ent: Entity,
+}
+
+impl<'a, P: PassPosition> DrawPass<P> for ExampleDrawPass<'a> {
+    /// Called every frame to queue actual drawing.
+    fn queue_draw(
+        &mut self,
+        session: &Session,
+        img_view: &ImageViewT,
+        cmd_buffer: &mut CommandBufferT,
+    ) -> anyhow::Result<()> {
+        // Commit any changes to our vertex buffers
+        // We queue this first so that it's executed before any draw commands
+        self.draw_buffers
+            .vertex_buffer
+            .record_commit_cmds(cmd_buffer)?;
+        self.draw_buffers
+            .index_buffer
+            .record_commit_cmds(cmd_buffer)?;
+
+        // Get framebuffer
+        let fb = self.surface_resources.framebuffers.get_next();
+
+        // Get state
+        let (state,) = <(&ExampleState,)>::query().get(&session.world, self.state_ent)?;
+
+        // Begin render pass & bind everything needed
+        unsafe {
+            cmd_buffer.begin_render_pass(
+                &self.surface_resources.pipeline.renderpass,
+                fb,
+                self.surface_resources.pipeline.render_area,
+                vec![RenderAttachmentInfo {
+                    image_view: img_view,
+                    clear_value: ClearValue {
+                        color: ClearColor {
+                            float32: [0.0, 0.0, 0.0, 1.0],
+                        },
+                    },
+                }]
+                .into_iter(),
+                SubpassContents::Inline,
+            );
+            cmd_buffer.bind_graphics_pipeline(&self.surface_resources.pipeline.pipeline);
+
+            // Bind buffers
+            cmd_buffer.bind_vertex_buffers(
+                0,
+                once((
+                    self.draw_buffers.vertex_buffer.get_buffer(),
+                    SubRange {
+                        offset: 0,
+                        size: None,
+                    },
+                )),
+            );
+            cmd_buffer.bind_index_buffer(
+                self.draw_buffers.index_buffer.get_buffer(),
+                SubRange {
+                    offset: 0,
+                    size: None,
+                },
+                hal::IndexType::U16,
+            );
+        }
+
+        // Draw an example
+        self.draw_buffers.index_buffer[0] = (0, 1, 2);
+        self.draw_buffers.vertex_buffer[0] = Vertex(Vector2::new(0.5, 0.5), state.color());
+        self.draw_buffers.vertex_buffer[1] = Vertex(Vector2::new(0.0, -0.5), state.color());
+        self.draw_buffers.vertex_buffer[2] = Vertex(Vector2::new(-0.5, 0.5), state.color());
+
+        unsafe {
+            cmd_buffer.draw_indexed(0..3, 0, 0..1);
+        }
+
+        // Remember to clean up afterwards!
+        unsafe {
+            cmd_buffer.end_render_pass();
+        }
+
+        Ok(())
+    }
+
+    /// Destroy all our vulkan objects
+    fn deactivate(self, context: &mut RenderingContext) -> Result<()> {
+        self.draw_buffers.deactivate(context);
+        self.surface_resources.deactivate(context)?;
+
+        Ok(())
+    }
+
+    /// Deal with a surface change
+    fn handle_surface_change(
+        mut self,
+        _session: &Session,
+        context: &mut RenderingContext,
+    ) -> Result<Self> {
+        // We need to make sure there's never an invalid value for self.surface_resources,
+        // and that we deactivate everything in case of an error (since we'll be dropped in that case).
+        let new_resources = match SurfaceDependentResources::new::<P>(context) {
+            Ok(x) => x,
+            Err(e) => {
+                <Self as DrawPass<P>>::deactivate(self, context)?;
+
+                return Err(e);
+            }
+        };
+
+        let old_resources = self.surface_resources;
+        self.surface_resources = new_resources;
+
+        match old_resources.deactivate(context) {
+            Ok(_) => Ok(self),
+            Err(e) => {
+                <Self as DrawPass<P>>::deactivate(self, context)?;
+                Err(e)
+            }
+        }
+    }
+}
+
+impl<'a, P: PassPosition> IntoDrawPass<ExampleDrawPass<'a>, P> for ExampleDrawPassConfig {
+    /// Create our example draw pass
+    fn init(
+        self,
+        _session: &mut Session,
+        context: &mut RenderingContext,
+    ) -> Result<ExampleDrawPass<'a>> {
+        let surface_resources = SurfaceDependentResources::new::<P>(context)?;
+        let draw_buffers =
+            match DrawBuffers::from_context(context).context("Error creating draw buffers") {
+                Ok(x) => x,
+                Err(e) => {
+                    surface_resources.deactivate(context)?;
+                    return Err(e);
+                }
+            };
+
+        Ok(ExampleDrawPass {
+            draw_buffers,
+            surface_resources,
+            state_ent: self.state_ent,
+        })
+    }
+
+    fn find_aux_queues(
+        _adapter: &Adapter,
+        _queue_negotiator: &mut QueueFamilyNegotiator,
+    ) -> Result<()> {
+        // We don't need any queues, but we'd need code to find their families here if we did.
+        Ok(())
+    }
+}
+
+/// Used to store resources which depend on the surface, for convenience in handle_surface_change
+struct SurfaceDependentResources {
+    pub pipeline: CompletePipeline,
+    pub framebuffers: TargetSpecificResources<FramebufferT>,
+}
+
+impl SurfaceDependentResources {
+    pub fn new<P: PassPosition>(context: &mut RenderingContext) -> Result<Self> {
+        let (pipeline, framebuffers) = {
+            // Our graphics pipeline
+            // Vulkan has a lot of config, so this is basically always going to be a big builder block
+            let pipeline_spec = PipelineSpecBuilder::default()
+                .rasterizer(Rasterizer {
+                    polygon_mode: PolygonMode::Fill,
+                    cull_face: Face::NONE,
+                    front_face: FrontFace::CounterClockwise,
+                    depth_clamping: false,
+                    depth_bias: None,
+                    conservative: true,
+                    line_width: State::Static(1.0),
+                })
+                .depth_stencil(DepthStencilDesc {
+                    depth: None,
+                    depth_bounds: false,
+                    stencil: None,
+                })
+                .blender(BlendDesc {
+                    logic_op: Some(LogicOp::Copy),
+                    targets: vec![ColorBlendDesc {
+                        mask: ColorMask::ALL,
+                        blend: Some(BlendState {
+                            color: BlendOp::Add {
+                                src: Factor::SrcAlpha,
+                                dst: Factor::OneMinusSrcAlpha,
+                            },
+                            alpha: BlendOp::Add {
+                                src: Factor::SrcAlpha,
+                                dst: Factor::OneMinusSrcAlpha,
+                            },
+                        }),
+                    }],
+                })
+                .primitive_assembler(VertexPrimitiveAssemblerSpec::with_buffers(
+                    InputAssemblerDesc::new(Primitive::TriangleList),
+                    vec![VertexBufferSpec {
+                        attributes: vec![Format::Rg32Sfloat, Format::Rgb32Sfloat],
+                        rate: VertexInputRate::Vertex,
+                    }],
+                ))
+                .shader_vertex(ShaderDesc {
+                    source: include_str!("./data/shader.vert").to_string(),
+                    entry: "main".to_string(),
+                    kind: ShaderKind::Vertex,
+                })
+                .shader_fragment(ShaderDesc {
+                    source: include_str!("./data/shader.frag").to_string(),
+                    entry: "main".to_string(),
+                    kind: ShaderKind::Fragment,
+                })
+                .renderpass(RenderpassSpec {
+                    colors: vec![AttachmentSpec {
+                        attachment: Attachment {
+                            format: Some(context.properties().color_format),
+                            samples: 1,
+                            // Here we use PassPosition to get the proper operations
+                            // Since, for example, the last pass needs to finish in present mode.
+                            ops: P::attachment_ops(),
+                            stencil_ops: P::attachment_ops(),
+                            layouts: P::layout_as_range(),
+                        },
+                        // This is the layout we want to deal with in our `queue_draw` function.
+                        // It's almost certainly `Layout::ColorAttachmentOptimal`
+                        used_layout: Layout::ColorAttachmentOptimal,
+                    }],
+                    depth: None,
+                    inputs: vec![],
+                    resolves: vec![],
+                    preserves: vec![],
+                })
+                .build()
+                .context("Error building pipeline")?;
+
+            // Lock our device to actually build it
+            // Try to lock the device for as little time as possible
+            let mut device = context.lock_device()?;
+
+            let pipeline = pipeline_spec
+                .build(&mut device, context.properties().extent, empty())
+                .context("Error building pipeline")?;
+
+            // Our framebuffers just have the swapchain framebuffer attachment
+            // TargetSpecificResources makes sure we use a different one each frame.
+            let fat = context.properties().swapchain_framebuffer_attachment();
+            let framebuffers = TargetSpecificResources::new(
+                || unsafe {
+                    Ok(device.create_framebuffer(
+                        &pipeline.renderpass,
+                        IntoIter::new([fat.clone()]),
+                        context.properties().extent,
+                    )?)
+                },
+                context.properties().image_count as usize,
+            )?;
+
+            (pipeline, framebuffers)
+        };
+
+        Ok(Self {
+            pipeline,
+            framebuffers,
+        })
+    }
+
+    pub fn deactivate(self, context: &mut RenderingContext) -> Result<()> {
+        unsafe {
+            let mut device = context.lock_device()?;
+            for fb in self.framebuffers.dissolve() {
+                device.destroy_framebuffer(fb);
+            }
+
+            self.pipeline.deactivate(&mut device);
+        }
+
+        Ok(())
+    }
+}