372 lines
13 KiB
Rust
372 lines
13 KiB
Rust
|
|
use super::glsl;
|
|
use super::shaders;
|
|
use gl;
|
|
use cgmath::{Point3, Matrix4, SquareMatrix};
|
|
use collision::{self, Frustum, Sphere};
|
|
use std::collections::HashMap;
|
|
use std::hash::BuildHasherDefault;
|
|
use std::sync::{Arc, RwLock};
|
|
use types::hash::FNVHash;
|
|
use shared::Direction;
|
|
use byteorder::{WriteBytesExt, NativeEndian};
|
|
use model::BlockVertex;
|
|
|
|
pub struct Manager {
|
|
collections: Vec<Collection>,
|
|
|
|
index_buffer: gl::Buffer,
|
|
index_type: gl::Type,
|
|
max_index: usize,
|
|
}
|
|
|
|
pub const DEFAULT: CollectionKey = CollectionKey(0);
|
|
pub const SUN: CollectionKey = CollectionKey(1);
|
|
|
|
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
|
|
pub struct CollectionKey(usize);
|
|
|
|
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
|
|
pub struct ModelKey(CollectionKey, usize);
|
|
|
|
impl Manager {
|
|
pub fn new(greg: &glsl::Registry) -> Manager {
|
|
let mut m = Manager {
|
|
collections: vec![],
|
|
|
|
index_buffer: gl::Buffer::new(),
|
|
index_type: gl::UNSIGNED_SHORT,
|
|
max_index: 0,
|
|
};
|
|
m.add_collection(
|
|
&greg.get("model_vertex"),
|
|
&greg.get("model_frag"),
|
|
gl::SRC_ALPHA, gl::ONE_MINUS_SRC_ALPHA
|
|
);
|
|
m.add_collection(
|
|
&greg.get("sun_vertex"),
|
|
&greg.get("sun_frag"),
|
|
gl::SRC_ALPHA, gl::ONE_FACTOR
|
|
);
|
|
m
|
|
}
|
|
|
|
pub fn add_collection(&mut self, vert: &str, frag: &str, blend_s: gl::Factor, blend_d: gl::Factor) -> CollectionKey {
|
|
let collection = Collection {
|
|
shader: ModelShader::new_manual(vert, frag),
|
|
models: HashMap::with_hasher(BuildHasherDefault::default()),
|
|
blend_s: blend_s,
|
|
blend_d: blend_d,
|
|
next_id: 0,
|
|
};
|
|
self.collections.push(collection);
|
|
CollectionKey(self.collections.len())
|
|
}
|
|
|
|
pub fn get_model(&mut self, key: ModelKey) -> Option<&mut Model> {
|
|
let collection = &mut self.collections[(key.0).0];
|
|
collection.models.get_mut(&key)
|
|
}
|
|
|
|
pub fn create_model(&mut self, ckey: CollectionKey, parts: Vec<Vec<Vertex>>) -> ModelKey {
|
|
let array = gl::VertexArray::new();
|
|
array.bind();
|
|
self.index_buffer.bind(gl::ELEMENT_ARRAY_BUFFER);
|
|
let buffer = gl::Buffer::new();
|
|
buffer.bind(gl::ARRAY_BUFFER);
|
|
|
|
let mut model = {
|
|
let collection = &mut self.collections[ckey.0];
|
|
collection.shader.program.use_program();
|
|
collection.shader.position.enable();
|
|
collection.shader.texture_info.enable();
|
|
collection.shader.texture_offset.enable();
|
|
collection.shader.color.enable();
|
|
collection.shader.id.enable();
|
|
collection.shader.position.vertex_pointer(3, gl::FLOAT, false, 36, 0);
|
|
collection.shader.texture_info.vertex_pointer(4, gl::UNSIGNED_SHORT, false, 36, 12);
|
|
collection.shader.texture_offset.vertex_pointer_int(3, gl::SHORT, 36, 20);
|
|
collection.shader.color.vertex_pointer(4, gl::UNSIGNED_BYTE, true, 36, 28);
|
|
collection.shader.id.vertex_pointer_int(4, gl::UNSIGNED_BYTE, 36, 32);
|
|
|
|
let mut model = Model {
|
|
// For culling only
|
|
x: 0.0,
|
|
y: 0.0,
|
|
z: 0.0,
|
|
radius: 0.0,
|
|
// Per a part
|
|
matrix: Vec::with_capacity(parts.len()),
|
|
colors: Vec::with_capacity(parts.len()),
|
|
block_light: 15.0,
|
|
sky_light: 15.0,
|
|
|
|
array: array,
|
|
buffer: buffer,
|
|
buffer_size: 0,
|
|
count: 0,
|
|
|
|
counts: Vec::with_capacity(parts.len()),
|
|
offsets: Vec::with_capacity(parts.len()),
|
|
|
|
verts: vec![],
|
|
};
|
|
|
|
for (i, part) in parts.into_iter().enumerate() {
|
|
model.matrix.push(Matrix4::identity());
|
|
model.colors.push([1.0, 1.0, 1.0, 1.0]);
|
|
model.counts.push(((part.len() / 4) * 6) as i32);
|
|
model.offsets.push((model.verts.len() / 4) * 6);
|
|
for mut pp in part {
|
|
pp.id = i as u8;
|
|
model.verts.push(pp);
|
|
}
|
|
}
|
|
model
|
|
};
|
|
|
|
Self::rebuild_model(&mut model);
|
|
if self.max_index < model.count {
|
|
let (data, ty) = super::generate_element_buffer(model.count);
|
|
self.index_buffer.bind(gl::ELEMENT_ARRAY_BUFFER);
|
|
self.index_buffer.set_data(gl::ELEMENT_ARRAY_BUFFER, &data, gl::DYNAMIC_DRAW);
|
|
self.max_index = model.count;
|
|
self.index_type = ty;
|
|
}
|
|
|
|
let collection = &mut self.collections[ckey.0];
|
|
let key = ModelKey(ckey, collection.next_id);
|
|
collection.next_id += 1;
|
|
collection.models.insert(key, model);
|
|
|
|
key
|
|
}
|
|
|
|
pub fn remove_model(&mut self, key: ModelKey) {
|
|
let collection = &mut self.collections[(key.0).0];
|
|
collection.models.remove(&key);
|
|
}
|
|
|
|
fn rebuild_model(model: &mut Model) {
|
|
model.array.bind();
|
|
model.count = (model.verts.len() / 4) * 6;
|
|
|
|
let mut buffer = Vec::with_capacity(36 * model.verts.len());
|
|
for vert in &model.verts {
|
|
let _ = buffer.write_f32::<NativeEndian>(vert.x);
|
|
let _ = buffer.write_f32::<NativeEndian>(vert.y);
|
|
let _ = buffer.write_f32::<NativeEndian>(vert.z);
|
|
let _ = buffer.write_u16::<NativeEndian>(vert.texture.get_x() as u16);
|
|
let _ = buffer.write_u16::<NativeEndian>(vert.texture.get_y() as u16);
|
|
let _ = buffer.write_u16::<NativeEndian>(vert.texture.get_width() as u16);
|
|
let _ = buffer.write_u16::<NativeEndian>(vert.texture.get_height() as u16);
|
|
let _ = buffer.write_i16::<NativeEndian>(((vert.texture.get_width() as f64) * 16.0 * vert.texture_x) as i16);
|
|
let _ = buffer.write_i16::<NativeEndian>(((vert.texture.get_height() as f64) * 16.0 * vert.texture_y) as i16);
|
|
let _ = buffer.write_i16::<NativeEndian>(vert.texture.atlas as i16);
|
|
let _ = buffer.write_i16::<NativeEndian>(0);
|
|
let _ = buffer.write_u8(vert.r);
|
|
let _ = buffer.write_u8(vert.g);
|
|
let _ = buffer.write_u8(vert.b);
|
|
let _ = buffer.write_u8(vert.a);
|
|
let _ = buffer.write_u8(vert.id);
|
|
let _ = buffer.write_u8(0);
|
|
let _ = buffer.write_u8(0);
|
|
let _ = buffer.write_u8(0);
|
|
}
|
|
|
|
model.buffer.bind(gl::ARRAY_BUFFER);
|
|
if buffer.len() < model.buffer_size {
|
|
model.buffer.re_set_data(gl::ARRAY_BUFFER, &buffer);
|
|
} else {
|
|
model.buffer.set_data(gl::ARRAY_BUFFER, &buffer, gl::DYNAMIC_DRAW);
|
|
model.buffer_size = buffer.len();
|
|
}
|
|
}
|
|
|
|
pub fn rebuild_models(&mut self, version: usize, textures: &Arc<RwLock<super::TextureManager>>) {
|
|
for collection in &mut self.collections {
|
|
for (_, model) in &mut collection.models {
|
|
for vert in &mut model.verts {
|
|
vert.texture = if vert.texture.version == version {
|
|
vert.texture.clone()
|
|
} else {
|
|
let mut new = super::Renderer::get_texture(&textures, &vert.texture.name);
|
|
new.rel_x = vert.texture.rel_x;
|
|
new.rel_y = vert.texture.rel_y;
|
|
new.rel_width = vert.texture.rel_width;
|
|
new.rel_height = vert.texture.rel_height;
|
|
new.is_rel = vert.texture.is_rel;
|
|
new
|
|
};
|
|
}
|
|
Self::rebuild_model(model);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn draw(&mut self, frustum: &Frustum<f32>, perspective_matrix: &Matrix4<f32>, camera_matrix: &Matrix4<f32>, light_level: f32, sky_offset: f32) {
|
|
let m = if self.index_type == gl::UNSIGNED_SHORT {
|
|
2
|
|
} else {
|
|
4
|
|
};
|
|
|
|
gl::enable(gl::BLEND);
|
|
for collection in &self.collections {
|
|
collection.shader.program.use_program();
|
|
collection.shader.perspective_matrix.set_matrix4(perspective_matrix);
|
|
collection.shader.camera_matrix.set_matrix4(camera_matrix);
|
|
collection.shader.texture.set_int(0);
|
|
collection.shader.sky_offset.set_float(sky_offset);
|
|
collection.shader.light_level.set_float(light_level);
|
|
gl::blend_func(collection.blend_s, collection.blend_d);
|
|
|
|
for model in collection.models.values() {
|
|
if model.radius > 0.0 && frustum.contains(Sphere {
|
|
center: Point3::new(model.x, -model.y, model.z),
|
|
radius: model.radius
|
|
}) == collision::Relation::Out {
|
|
continue;
|
|
}
|
|
model.array.bind();
|
|
collection.shader.lighting.set_float2(model.block_light, model.sky_light);
|
|
if model.counts.len() > 1 {
|
|
let mut offsets = model.offsets.clone();
|
|
for offset in &mut offsets {
|
|
*offset *= m;
|
|
}
|
|
collection.shader.model_matrix.set_matrix4_multi(&model.matrix);
|
|
collection.shader.color_mul.set_float_mutli_raw(model.colors.as_ptr() as *const _, model.colors.len());
|
|
gl::multi_draw_elements(gl::TRIANGLES, &model.counts, self.index_type, &offsets);
|
|
} else {
|
|
collection.shader.model_matrix.set_matrix4_multi(&model.matrix);
|
|
collection.shader.color_mul.set_float_mutli_raw(model.colors.as_ptr() as *const _, model.colors.len());
|
|
gl::draw_elements(gl::TRIANGLES, model.counts[0], self.index_type, model.offsets[0] * m);
|
|
}
|
|
}
|
|
}
|
|
gl::disable(gl::BLEND);
|
|
}
|
|
}
|
|
|
|
struct Collection {
|
|
shader: ModelShader,
|
|
|
|
models: HashMap<ModelKey, Model, BuildHasherDefault<FNVHash>>,
|
|
blend_s: gl::Factor,
|
|
blend_d: gl::Factor,
|
|
|
|
next_id: usize,
|
|
}
|
|
|
|
pub struct Model {
|
|
// For culling only
|
|
pub x: f32,
|
|
pub y: f32,
|
|
pub z: f32,
|
|
pub radius: f32,
|
|
// Per a part
|
|
pub matrix: Vec<Matrix4<f32>>,
|
|
pub colors: Vec<[f32; 4]>,
|
|
pub block_light: f32,
|
|
pub sky_light: f32,
|
|
|
|
array: gl::VertexArray,
|
|
buffer: gl::Buffer,
|
|
buffer_size: usize,
|
|
count: usize,
|
|
|
|
counts: Vec<i32>,
|
|
offsets: Vec<usize>,
|
|
|
|
pub verts: Vec<Vertex>,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct Vertex {
|
|
pub x: f32,
|
|
pub y: f32,
|
|
pub z: f32,
|
|
pub texture: super::Texture,
|
|
pub texture_x: f64,
|
|
pub texture_y: f64,
|
|
pub r: u8,
|
|
pub g: u8,
|
|
pub b: u8,
|
|
pub a: u8,
|
|
pub id: u8,
|
|
}
|
|
|
|
init_shader! {
|
|
Program ModelShader {
|
|
vert = "model_vertex",
|
|
frag = "model_frag",
|
|
attribute = {
|
|
position => "aPosition",
|
|
texture_info => "aTextureInfo",
|
|
texture_offset => "aTextureOffset",
|
|
color => "aColor",
|
|
id => "id",
|
|
},
|
|
uniform = {
|
|
perspective_matrix => "perspectiveMatrix",
|
|
camera_matrix => "cameraMatrix",
|
|
model_matrix => "modelMatrix[]",
|
|
texture => "textures",
|
|
light_level => "lightLevel",
|
|
sky_offset => "skyOffset",
|
|
lighting => "lighting",
|
|
color_mul => "colorMul[]",
|
|
},
|
|
}
|
|
}
|
|
|
|
// Helper methods
|
|
pub fn append_box(
|
|
verts: &mut Vec<Vertex>,
|
|
x: f32, y: f32, z: f32,
|
|
w: f32, h: f32, d: f32, textures: [Option<super::Texture>; 6]
|
|
) {
|
|
append_box_texture_scale(verts, x, y, z, w, h, d, textures, [
|
|
[1.0, 1.0],
|
|
[1.0, 1.0],
|
|
[1.0, 1.0],
|
|
[1.0, 1.0],
|
|
[1.0, 1.0],
|
|
[1.0, 1.0]
|
|
]);
|
|
}
|
|
pub fn append_box_texture_scale(
|
|
verts: &mut Vec<Vertex>,
|
|
x: f32, y: f32, z: f32,
|
|
w: f32, h: f32, d: f32,
|
|
textures: [Option<super::Texture>; 6], texture_scale: [[f64; 2]; 6]) {
|
|
for dir in Direction::all() {
|
|
let tex = textures[dir.index()].clone();
|
|
if tex.is_none() {
|
|
continue;
|
|
}
|
|
let tex = tex.unwrap();
|
|
for vert in BlockVertex::face_by_direction(dir) {
|
|
let (rr, gg, bb) = if dir == Direction::West || dir == Direction::East {
|
|
((255.0 * 0.8) as u8, (255.0 * 0.8) as u8, (255.0 * 0.8) as u8)
|
|
} else {
|
|
(255, 255, 255)
|
|
};
|
|
verts.push(Vertex {
|
|
x: vert.x * w + x,
|
|
y: vert.y * h + y,
|
|
z: vert.z * d + z,
|
|
texture: tex.clone(),
|
|
texture_x: (vert.toffsetx as f64) * texture_scale[dir.index()][0],
|
|
texture_y: (vert.toffsety as f64) * texture_scale[dir.index()][1],
|
|
r: rr,
|
|
g: gg,
|
|
b: bb,
|
|
a: 255,
|
|
id: 0,
|
|
});
|
|
}
|
|
}
|
|
}
|