14714
|
1 |
use integral_geometry::{GridIndex, Point, Rect, Size};
|
14705
|
2 |
use land2d::Land2D;
|
|
3 |
use vec2d::Vec2D;
|
14702
|
4 |
|
|
5 |
use super::gl::{
|
14705
|
6 |
Buffer, InputElement, InputFormat, InputLayout, Shader, Texture2D, VariableBinding,
|
14702
|
7 |
};
|
|
8 |
|
|
9 |
// TODO: temp
|
|
10 |
const VERTEX_SHADER: &'static str = r#"
|
|
11 |
#version 150
|
|
12 |
|
|
13 |
in vec2 Position;
|
|
14 |
in vec3 Uv;
|
|
15 |
|
|
16 |
out vec3 a_Uv;
|
|
17 |
|
|
18 |
//uniform Common {
|
|
19 |
uniform mat4 Projection;
|
|
20 |
//};
|
|
21 |
|
|
22 |
void main()
|
|
23 |
{
|
|
24 |
a_Uv = Uv;
|
|
25 |
gl_Position = Projection * vec4(Position, 0.0, 1.0);
|
|
26 |
}
|
|
27 |
"#;
|
|
28 |
|
|
29 |
const PIXEL_SHADER: &'static str = r#"
|
|
30 |
#version 150
|
|
31 |
|
|
32 |
in vec3 a_Uv;
|
|
33 |
|
|
34 |
uniform sampler2D Texture;
|
|
35 |
|
|
36 |
out vec4 Target;
|
|
37 |
|
|
38 |
void main()
|
|
39 |
{
|
|
40 |
Target = texture2D(Texture, a_Uv.xy);
|
|
41 |
}
|
|
42 |
"#;
|
|
43 |
|
|
44 |
pub struct MapTile {
|
|
45 |
// either index into GL texture array or emulated [Texture; N]
|
|
46 |
texture_index: u32,
|
|
47 |
|
|
48 |
width: u32,
|
|
49 |
height: u32,
|
|
50 |
}
|
|
51 |
|
|
52 |
#[repr(C)]
|
|
53 |
#[derive(Copy, Clone)]
|
|
54 |
pub struct TileVertex {
|
|
55 |
pos: [f32; 2],
|
|
56 |
// doesn't hurt to include another float, just in case..
|
|
57 |
uv: [f32; 3],
|
|
58 |
}
|
|
59 |
|
|
60 |
pub struct DrawTile {
|
|
61 |
texture_index: u32,
|
|
62 |
index_len: u32,
|
|
63 |
}
|
|
64 |
|
|
65 |
pub struct MapRenderer {
|
|
66 |
tiles: Vec<MapTile>,
|
|
67 |
textures: Vec<Texture2D>,
|
|
68 |
|
|
69 |
tile_vertex_buffer: Buffer,
|
|
70 |
tile_index_buffer: Buffer,
|
|
71 |
tile_vertices: Vec<TileVertex>,
|
|
72 |
tile_indices: Vec<u16>,
|
|
73 |
tile_draw_calls: Vec<DrawTile>,
|
|
74 |
index_offset: u16,
|
|
75 |
tile_shader: Shader,
|
|
76 |
tile_layout: InputLayout,
|
14705
|
77 |
|
14714
|
78 |
tile_size: Size,
|
|
79 |
num_tile_x: usize,
|
14702
|
80 |
}
|
|
81 |
|
|
82 |
impl MapRenderer {
|
14714
|
83 |
pub fn new(tile_size: Size) -> Self {
|
|
84 |
debug_assert!(tile_size.is_power_of_two());
|
|
85 |
|
14702
|
86 |
let tile_shader = Shader::new(
|
|
87 |
VERTEX_SHADER,
|
|
88 |
Some(PIXEL_SHADER),
|
|
89 |
&[
|
|
90 |
VariableBinding::Attribute("Position", 0),
|
|
91 |
VariableBinding::Attribute("Uv", 1),
|
|
92 |
VariableBinding::Sampler("Texture", 0),
|
14705
|
93 |
],
|
|
94 |
)
|
|
95 |
.unwrap();
|
14702
|
96 |
|
14714
|
97 |
let vertex_size = std::mem::size_of::<TileVertex>() as u32;
|
14702
|
98 |
let tile_layout = InputLayout::new(vec![
|
|
99 |
// position
|
|
100 |
InputElement {
|
|
101 |
shader_slot: 0,
|
|
102 |
buffer_slot: 0,
|
|
103 |
format: InputFormat::Float(gl::FLOAT, false),
|
|
104 |
components: 2,
|
14714
|
105 |
stride: vertex_size,
|
14705
|
106 |
offset: 0,
|
14702
|
107 |
},
|
|
108 |
// uv
|
|
109 |
InputElement {
|
|
110 |
shader_slot: 1,
|
|
111 |
buffer_slot: 0,
|
|
112 |
format: InputFormat::Float(gl::FLOAT, false),
|
|
113 |
components: 3,
|
14714
|
114 |
stride: vertex_size,
|
14705
|
115 |
offset: 8,
|
14702
|
116 |
},
|
|
117 |
]);
|
14705
|
118 |
|
14702
|
119 |
MapRenderer {
|
|
120 |
tiles: Vec::new(),
|
|
121 |
textures: Vec::new(),
|
14705
|
122 |
|
14702
|
123 |
tile_vertex_buffer: Buffer::empty(gl::ARRAY_BUFFER, gl::DYNAMIC_DRAW),
|
|
124 |
tile_index_buffer: Buffer::empty(gl::ELEMENT_ARRAY_BUFFER, gl::DYNAMIC_DRAW),
|
|
125 |
tile_vertices: Vec::new(),
|
|
126 |
tile_indices: Vec::new(),
|
|
127 |
index_offset: 0,
|
|
128 |
|
|
129 |
tile_draw_calls: Vec::new(),
|
|
130 |
tile_shader,
|
|
131 |
tile_layout,
|
|
132 |
|
14714
|
133 |
tile_size,
|
14702
|
134 |
num_tile_x: 0,
|
|
135 |
}
|
|
136 |
}
|
|
137 |
|
|
138 |
pub fn init(&mut self, land: &Vec2D<u32>) {
|
|
139 |
// clear tiles, but keep our textures for potential re-use
|
|
140 |
self.tiles.clear();
|
|
141 |
|
14714
|
142 |
let tw = self.tile_size.width;
|
|
143 |
let th = self.tile_size.height;
|
14702
|
144 |
let lw = land.width();
|
|
145 |
let lh = land.height();
|
14714
|
146 |
let num_tile_x = lw / tw;
|
|
147 |
let num_tile_y = lh / th;
|
14702
|
148 |
|
14714
|
149 |
self.num_tile_x = num_tile_x;
|
14702
|
150 |
|
|
151 |
for y in 0..num_tile_y {
|
|
152 |
for x in 0..num_tile_x {
|
|
153 |
let idx = x + y * num_tile_x;
|
|
154 |
|
|
155 |
let (data, stride) = {
|
|
156 |
let bpp = 4;
|
|
157 |
|
|
158 |
let offset = x * tw * bpp + y * th * lw * bpp;
|
|
159 |
|
|
160 |
let data = unsafe { &land.as_bytes()[offset..] };
|
|
161 |
let stride = land.width();
|
|
162 |
|
|
163 |
(data, stride as u32)
|
|
164 |
};
|
14705
|
165 |
|
14702
|
166 |
let texture_index = if idx >= self.textures.len() {
|
|
167 |
let texture = Texture2D::with_data(
|
|
168 |
data,
|
|
169 |
stride,
|
14714
|
170 |
self.tile_size.width as u32,
|
|
171 |
self.tile_size.height as u32,
|
14702
|
172 |
gl::RGBA8,
|
|
173 |
gl::RGBA,
|
|
174 |
gl::UNSIGNED_BYTE,
|
14705
|
175 |
gl::NEAREST,
|
14702
|
176 |
);
|
|
177 |
|
|
178 |
let texture_index = self.textures.len();
|
|
179 |
self.textures.push(texture);
|
|
180 |
|
|
181 |
texture_index
|
|
182 |
} else {
|
14714
|
183 |
let texture_region = Rect::at_origin(self.tile_size);
|
14702
|
184 |
|
14705
|
185 |
self.textures[idx].update(
|
|
186 |
texture_region,
|
|
187 |
data,
|
|
188 |
stride,
|
|
189 |
gl::RGBA,
|
|
190 |
gl::UNSIGNED_BYTE,
|
|
191 |
);
|
14702
|
192 |
idx
|
|
193 |
};
|
|
194 |
|
|
195 |
let tile = MapTile {
|
|
196 |
texture_index: texture_index as u32,
|
14705
|
197 |
|
14702
|
198 |
// TODO: are there ever non-power of two textures?
|
14714
|
199 |
width: self.tile_size.width as u32,
|
|
200 |
height: self.tile_size.height as u32,
|
14702
|
201 |
};
|
|
202 |
self.tiles.push(tile);
|
|
203 |
}
|
|
204 |
}
|
|
205 |
}
|
|
206 |
|
14705
|
207 |
pub fn update(&mut self, land: &Land2D<u32>, region: Rect) {}
|
14702
|
208 |
|
|
209 |
pub fn render(&mut self, viewport: Rect) {
|
|
210 |
self.tile_vertices.clear();
|
|
211 |
self.tile_indices.clear();
|
|
212 |
self.tile_draw_calls.clear();
|
|
213 |
self.index_offset = 0;
|
14705
|
214 |
|
14702
|
215 |
for (idx, tile) in self.tiles.iter().enumerate() {
|
14714
|
216 |
let tile_x = idx % self.num_tile_x;
|
|
217 |
let tile_y = idx / self.num_tile_x;
|
|
218 |
let tile_w = self.tile_size.width;
|
|
219 |
let tile_h = self.tile_size.width;
|
14702
|
220 |
|
14714
|
221 |
let origin = Point::new((tile_x * tile_w) as i32, (tile_y * tile_h) as i32);
|
|
222 |
let tile_rect = Rect::from_size(origin, self.tile_size);
|
14702
|
223 |
|
|
224 |
if viewport.intersects(&tile_rect) {
|
|
225 |
// lazy
|
|
226 |
//dbg!(origin);
|
|
227 |
let tile_x = origin.x as f32;
|
|
228 |
let tile_y = origin.y as f32;
|
|
229 |
let tile_w = tile_x + tile_w as f32;
|
|
230 |
let tile_h = tile_y + tile_h as f32;
|
|
231 |
let uv_depth = tile.texture_index as f32;
|
|
232 |
|
|
233 |
//dbg!(tile_x);
|
14705
|
234 |
let tl = TileVertex {
|
|
235 |
pos: [tile_x, tile_y],
|
|
236 |
uv: [0f32, 0f32, uv_depth],
|
|
237 |
};
|
|
238 |
let bl = TileVertex {
|
|
239 |
pos: [tile_x, tile_h],
|
|
240 |
uv: [0f32, 1f32, uv_depth],
|
|
241 |
};
|
|
242 |
let br = TileVertex {
|
|
243 |
pos: [tile_w, tile_h],
|
|
244 |
uv: [1f32, 1f32, uv_depth],
|
|
245 |
};
|
|
246 |
let tr = TileVertex {
|
|
247 |
pos: [tile_w, tile_y],
|
|
248 |
uv: [1f32, 0f32, uv_depth],
|
|
249 |
};
|
14702
|
250 |
|
|
251 |
self.tile_vertices.extend(&[tl, bl, br, tr]);
|
|
252 |
|
|
253 |
let i = self.index_offset;
|
14705
|
254 |
self.tile_indices
|
|
255 |
.extend(&[i + 0, i + 1, i + 2, i + 2, i + 3, i + 0]);
|
14702
|
256 |
self.index_offset += 4;
|
|
257 |
|
|
258 |
self.tile_draw_calls.push(DrawTile {
|
|
259 |
texture_index: tile.texture_index,
|
14705
|
260 |
index_len: 6,
|
14702
|
261 |
});
|
|
262 |
}
|
|
263 |
}
|
|
264 |
|
|
265 |
self.tile_vertex_buffer.write_typed(&self.tile_vertices);
|
|
266 |
self.tile_index_buffer.write_typed(&self.tile_indices);
|
|
267 |
|
14705
|
268 |
let _g = self.tile_layout.bind(
|
|
269 |
&[(0, &self.tile_vertex_buffer)],
|
|
270 |
Some(&self.tile_index_buffer),
|
|
271 |
);
|
14702
|
272 |
|
|
273 |
let ortho = {
|
|
274 |
let l = viewport.left() as f32;
|
14714
|
275 |
let w = viewport.width() as f32;
|
|
276 |
let h = viewport.height() as f32;
|
14702
|
277 |
let t = viewport.top() as f32;
|
|
278 |
|
|
279 |
[
|
14714
|
280 |
2f32 / w,
|
14705
|
281 |
0f32,
|
|
282 |
0f32,
|
|
283 |
0f32,
|
|
284 |
0f32,
|
14714
|
285 |
2f32 / -h,
|
14705
|
286 |
0f32,
|
|
287 |
0f32,
|
|
288 |
0f32,
|
|
289 |
0f32,
|
|
290 |
0.5f32,
|
|
291 |
0f32,
|
14714
|
292 |
-(2.0 * l + w) / w,
|
|
293 |
(2.0 * t + h) / h,
|
14705
|
294 |
0.5f32,
|
|
295 |
1f32,
|
14702
|
296 |
]
|
|
297 |
};
|
|
298 |
|
|
299 |
self.tile_shader.bind();
|
|
300 |
self.tile_shader.set_matrix("Projection", ortho.as_ptr());
|
14705
|
301 |
|
14702
|
302 |
let mut draw_offset = 0;
|
|
303 |
for draw_call in &self.tile_draw_calls {
|
|
304 |
unsafe {
|
14705
|
305 |
self.tile_shader
|
|
306 |
.bind_texture_2d(0, &self.textures[draw_call.texture_index as usize]);
|
|
307 |
|
14702
|
308 |
gl::DrawElements(
|
|
309 |
gl::TRIANGLES,
|
|
310 |
draw_call.index_len as i32,
|
|
311 |
gl::UNSIGNED_SHORT,
|
14705
|
312 |
draw_offset as *const _,
|
14702
|
313 |
);
|
|
314 |
}
|
|
315 |
|
|
316 |
draw_offset += draw_call.index_len * 2;
|
|
317 |
}
|
|
318 |
}
|
|
319 |
}
|