192 lines
5.9 KiB
Rust
192 lines
5.9 KiB
Rust
use crate::render;
|
|
use crate::render::model;
|
|
use cgmath::{Decomposed, Matrix4, Quaternion, Rad, Rotation3, Vector3};
|
|
|
|
pub struct SunModel {
|
|
sun: model::ModelKey,
|
|
moon: model::ModelKey,
|
|
last_phase: i32,
|
|
}
|
|
|
|
const SIZE: f32 = 50.0;
|
|
|
|
impl SunModel {
|
|
pub fn new(renderer: &mut render::Renderer) -> SunModel {
|
|
SunModel {
|
|
sun: SunModel::generate_sun(renderer),
|
|
moon: SunModel::generate_moon(renderer, 0),
|
|
last_phase: 0,
|
|
}
|
|
}
|
|
|
|
pub fn tick(&mut self, renderer: &mut render::Renderer, world_time: f64, world_age: i64) {
|
|
use std::f64::consts::PI;
|
|
let phase = ((world_age / 24000) % 8) as i32;
|
|
if phase != self.last_phase {
|
|
renderer.model.remove_model(self.moon);
|
|
self.moon = SunModel::generate_moon(renderer, phase);
|
|
self.last_phase = phase;
|
|
}
|
|
|
|
let time = world_time / 12000.0;
|
|
let ox = (time * PI).cos() * 300.0;
|
|
let oy = (time * PI).sin() * 300.0;
|
|
|
|
{
|
|
let sun = renderer.model.get_model(self.sun).unwrap();
|
|
sun.matrix[0] = Matrix4::from(Decomposed {
|
|
scale: 1.0,
|
|
rot: Quaternion::from_angle_z(Rad(-(time * PI) as f32)),
|
|
disp: Vector3::new(
|
|
(renderer.camera.pos.x + ox) as f32,
|
|
-(renderer.camera.pos.y + oy) as f32,
|
|
renderer.camera.pos.z as f32,
|
|
),
|
|
});
|
|
}
|
|
|
|
{
|
|
let moon = renderer.model.get_model(self.moon).unwrap();
|
|
moon.matrix[0] = Matrix4::from(Decomposed {
|
|
scale: 1.0,
|
|
rot: Quaternion::from_angle_z(Rad((PI - (time * PI)) as f32)),
|
|
disp: Vector3::new(
|
|
(renderer.camera.pos.x - ox) as f32,
|
|
-(renderer.camera.pos.y - oy) as f32,
|
|
renderer.camera.pos.z as f32,
|
|
),
|
|
});
|
|
}
|
|
}
|
|
|
|
pub fn remove(&mut self, renderer: &mut render::Renderer) {
|
|
renderer.model.remove_model(self.sun);
|
|
renderer.model.remove_model(self.moon);
|
|
}
|
|
|
|
pub fn generate_sun(renderer: &mut render::Renderer) -> model::ModelKey {
|
|
let tex = render::Renderer::get_texture(renderer.get_textures_ref(), "environment/sun");
|
|
renderer.model.create_model(
|
|
model::SUN,
|
|
vec![vec![
|
|
model::Vertex {
|
|
x: 0.0,
|
|
y: -SIZE,
|
|
z: -SIZE,
|
|
texture_x: 0.0,
|
|
texture_y: 1.0,
|
|
texture: tex.clone(),
|
|
r: 255,
|
|
g: 255,
|
|
b: 255,
|
|
a: 0,
|
|
id: 0,
|
|
},
|
|
model::Vertex {
|
|
x: 0.0,
|
|
y: SIZE,
|
|
z: -SIZE,
|
|
texture_x: 0.0,
|
|
texture_y: 0.0,
|
|
texture: tex.clone(),
|
|
r: 255,
|
|
g: 255,
|
|
b: 255,
|
|
a: 0,
|
|
id: 0,
|
|
},
|
|
model::Vertex {
|
|
x: 0.0,
|
|
y: -SIZE,
|
|
z: SIZE,
|
|
texture_x: 1.0,
|
|
texture_y: 1.0,
|
|
texture: tex.clone(),
|
|
r: 255,
|
|
g: 255,
|
|
b: 255,
|
|
a: 0,
|
|
id: 0,
|
|
},
|
|
model::Vertex {
|
|
x: 0.0,
|
|
y: SIZE,
|
|
z: SIZE,
|
|
texture_x: 1.0,
|
|
texture_y: 0.0,
|
|
texture: tex,
|
|
r: 255,
|
|
g: 255,
|
|
b: 255,
|
|
a: 0,
|
|
id: 0,
|
|
},
|
|
]],
|
|
)
|
|
}
|
|
|
|
pub fn generate_moon(renderer: &mut render::Renderer, phase: i32) -> model::ModelKey {
|
|
let tex =
|
|
render::Renderer::get_texture(renderer.get_textures_ref(), "environment/moon_phases");
|
|
let mpx = (phase % 4) as f64 * (1.0 / 4.0);
|
|
let mpy = (phase / 4) as f64 * (1.0 / 2.0);
|
|
renderer.model.create_model(
|
|
model::SUN,
|
|
vec![vec![
|
|
model::Vertex {
|
|
x: 0.0,
|
|
y: -SIZE,
|
|
z: -SIZE,
|
|
texture_x: mpx,
|
|
texture_y: mpy + (1.0 / 2.0),
|
|
texture: tex.clone(),
|
|
r: 255,
|
|
g: 255,
|
|
b: 255,
|
|
a: 0,
|
|
id: 0,
|
|
},
|
|
model::Vertex {
|
|
x: 0.0,
|
|
y: SIZE,
|
|
z: -SIZE,
|
|
texture_x: mpx,
|
|
texture_y: mpy,
|
|
texture: tex.clone(),
|
|
r: 255,
|
|
g: 255,
|
|
b: 255,
|
|
a: 0,
|
|
id: 0,
|
|
},
|
|
model::Vertex {
|
|
x: 0.0,
|
|
y: -SIZE,
|
|
z: SIZE,
|
|
texture_x: mpx + (1.0 / 4.0),
|
|
texture_y: mpy + (1.0 / 2.0),
|
|
texture: tex.clone(),
|
|
r: 255,
|
|
g: 255,
|
|
b: 255,
|
|
a: 0,
|
|
id: 0,
|
|
},
|
|
model::Vertex {
|
|
x: 0.0,
|
|
y: SIZE,
|
|
z: SIZE,
|
|
texture_x: mpx + (1.0 / 4.0),
|
|
texture_y: mpy,
|
|
texture: tex,
|
|
r: 255,
|
|
g: 255,
|
|
b: 255,
|
|
a: 0,
|
|
id: 0,
|
|
},
|
|
]],
|
|
)
|
|
}
|
|
}
|