1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
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),
// }
}
|
