set up rendering with miniquad

2 files changed, 104 insertions, 38 deletions

diff --git a/src/main.rs b/src/main.rs
index f0b0ccb..735c25d 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -5,5 +5,6 @@ mod render;
 
 fn main() {
     println!("Warming up...");
-    render::run();
+    render::graphics();
+    println!("Hello!");
 }
diff --git a/src/render.rs b/src/render.rs
index 8389ab9..964a022 100644
--- a/src/render.rs
+++ b/src/render.rs
@@ -1,50 +1,115 @@
-use std::io;
-use std::io::Write;
+use miniquad::*;
 
-use vulkano as vk;
-use vk::instance::{Instance, InstanceExtensions, PhysicalDevice};
+#[repr(C)]
+struct Vec2 {
+    x: f32,
+    y: f32,
+}
+#[repr(C)]
+struct Vertex {
+    pos: Vec2,
+    uv: Vec2,
+}
+
+struct Stage {
+    pipeline: Pipeline,
+    bindings: Bindings,
+}
 
-/// Reads a single line after prompting the player.
-pub fn read(prompt: &str) -> String {
-    print!("{}", prompt);
-    io::stdout().flush().expect("unable to prompt user");
+impl Stage {
+    pub fn new(ctx: &mut Context) -> Stage {
+        #[rustfmt::skip]
+        let vertices: [Vertex; 4] = [
+            Vertex { pos : Vec2 { x: -1., y: -1. }, uv: Vec2 { x: 0., y: 0. } },
+            Vertex { pos : Vec2 { x:  1., y: -1. }, uv: Vec2 { x: 1., y: 0. } },
+            Vertex { pos : Vec2 { x:  1., y:  1. }, uv: Vec2 { x: 1., y: 1. } },
+            Vertex { pos : Vec2 { x: -1., y:  1. }, uv: Vec2 { x: 0., y: 1. } },
+        ];
+        let vertex_buffer = Buffer::immutable(ctx, BufferType::VertexBuffer, &vertices);
 
-    let mut input = String::new();
-    io::stdin()
-        .read_line(&mut input)
-        .expect("unable to read user input");
+        let indices: [u16; 6] = [0, 1, 2, 0, 2, 3];
+        let index_buffer = Buffer::immutable(ctx, BufferType::IndexBuffer, &indices);
 
-    return input.trim().to_string();
-}
+        let pixels: [u8; 512*512*4] = [0x77; 512*512*4];
+        let texture = Texture::from_rgba8(ctx, 512, 512, &pixels);
+
+        let bindings = Bindings {
+            vertex_buffers: vec![vertex_buffer],
+            index_buffer: index_buffer,
+            images: vec![texture],
+        };
 
-pub fn select_device(instance: &Instance) -> Option<device> {
-    // get all the devices
-    let devices = PhysicalDevice::enumerate(&instance).to_vec();
-
-    // easy choice
-    if devices.is_empty() {
-        println!("No devices detected >:(");
-        return None;
-    } else if devices.len() == 1 {
-        println!("Using only device present");
-        return Some(devices[1]);
+        let shader = Shader::new(ctx, shader::VERTEX, shader::FRAGMENT, shader::SHADER_META);
+
+        let pipeline = Pipeline::new(
+            ctx,
+            &[BufferLayout::default()],
+            &[
+                VertexAttribute::new("pos", VertexFormat::Float2),
+                VertexAttribute::new("uv", VertexFormat::Float2),
+            ],
+            shader,
+        );
+
+        Stage { pipeline, bindings }
     }
+}
+
+impl EventHandler for Stage {
+    fn update(&mut self, _ctx: &mut Context) {}
+
+    fn draw(&mut self, ctx: &mut Context) {
+        ctx.begin_default_pass(Default::default());
 
-    // leave the choice up to the user
-    println!("Detected the following devices:");
-    for (i, device) in devices.iter().enumerate() {
-        println!("({}) {}", i, device);
+        ctx.apply_pipeline(&self.pipeline);
+        ctx.apply_bindings(&self.bindings);
+
+        // ctx.apply_uniforms(&shader::Uniforms {});
+
+        ctx.draw(0, 6, 1);
+        ctx.end_render_pass();
+        ctx.commit_frame();
     }
+}
 
-    // not really forgiving haha
-    let number = usize::from(read("Which device would you like to use: "));
-    let device = devices.get(number);
-    device
+pub fn graphics() {
+    miniquad::start(conf::Conf::default(), |mut ctx| {
+        UserData::owning(Stage::new(&mut ctx), ctx)
+    });
 }
 
-pub fn run() {
-    let instance = Instance::new(None, &InstanceExtensions::none(), None)
-        .expect("failed to create instance");
+mod shader {
+    use miniquad::*;
+
+    pub const VERTEX: &str = r#"#version 100
+    attribute vec2 pos;
+    attribute vec2 uv;
+
+    varying lowp vec2 texcoord;
+
+    void main() {
+        gl_Position = vec4(pos, 0, 1);
+        texcoord = uv;
+    }"#;
+
+    pub const FRAGMENT: &str = r#"#version 100
+    varying lowp vec2 texcoord;
+
+    uniform sampler2D tex;
+
+    void main() {
+        gl_FragColor = texture2D(tex, texcoord);
+    }"#;
+
+    pub const SHADER_META: ShaderMeta = ShaderMeta {
+        images: &["tex"],
+        uniforms: UniformBlockLayout {
+            uniforms: &[], // &[("offset", UniformType::Float2)],
+        },
+    };
 
-    let device = select_device(&instance);
+    // #[repr(C)]
+    // pub struct Uniforms {
+    //     // pub offset: (f32, f32),
+    // }
 }