128 lines
3.3 KiB
Rust
128 lines
3.3 KiB
Rust
use miniquad::*;
|
|
use crate::quad::{Node, Embed};
|
|
|
|
#[repr(C)]
|
|
struct Vec2 {
|
|
x: f32,
|
|
y: f32,
|
|
}
|
|
#[repr(C)]
|
|
struct Vertex {
|
|
pos: Vec2,
|
|
uv: Vec2,
|
|
}
|
|
|
|
struct Stage<A: Embed, B: Embed> {
|
|
pipeline: Pipeline,
|
|
bindings: Bindings,
|
|
texture: Texture,
|
|
node: Node<A, B>,
|
|
}
|
|
|
|
const SIZE: usize = 4;
|
|
|
|
impl<A: Embed, B: Embed> Stage<A, B> {
|
|
pub fn new(ctx: &mut Context) -> Self {
|
|
#[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 indices: [u16; 6] = [0, 1, 2, 0, 2, 3];
|
|
let index_buffer = Buffer::immutable(ctx, BufferType::IndexBuffer, &indices);
|
|
|
|
let pixels: [u8; SIZE*SIZE*4] = [0x77; SIZE*SIZE*4];
|
|
let texture = Texture::from_rgba8(ctx, SIZE as u16, SIZE as u16, &pixels);
|
|
|
|
let bindings = Bindings {
|
|
vertex_buffers: vec![vertex_buffer],
|
|
index_buffer: index_buffer,
|
|
images: vec![texture],
|
|
};
|
|
|
|
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, texture, node: todo!() }
|
|
}
|
|
}
|
|
|
|
impl<A: Embed, B: Embed> EventHandler for Stage<A, B> {
|
|
fn update(&mut self, ctx: &mut Context) {
|
|
let t = date::now();
|
|
let bright = t.sin()*0.5+0.5;
|
|
let bytes = [(bright * 255.0) as u8; SIZE*SIZE*4];
|
|
|
|
self.texture.update(ctx, &bytes)
|
|
}
|
|
|
|
fn draw(&mut self, ctx: &mut Context) {
|
|
ctx.begin_default_pass(Default::default());
|
|
|
|
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();
|
|
}
|
|
}
|
|
|
|
pub fn graphics() {
|
|
// assert_eq!((2 as usize).pow(node.depth as u32), SIZE);
|
|
// miniquad::start(conf::Conf::default(), move |mut ctx| {
|
|
// UserData::owning(Stage::new(&mut ctx), ctx)
|
|
// });
|
|
}
|
|
|
|
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)],
|
|
},
|
|
};
|
|
|
|
// #[repr(C)]
|
|
// pub struct Uniforms {
|
|
// // pub offset: (f32, f32),
|
|
// }
|
|
}
|