use std::sync::Arc;
use threers::cameras::Camera;
use threers::{
AmbientLight, Color, DataTexture, DirectionalLight, Mesh, Object3D, PerspectiveCamera,
Renderer, Scene, SphereGeometry, StandardMaterial, TextureFormat, Vector3,
};
use winit::{
event::{Event, WindowEvent},
event_loop::EventLoop,
window::WindowBuilder,
};
fn main() {
env_logger::init();
pollster::block_on(run());
}
async fn run() {
let event_loop = EventLoop::new().expect("event loop");
let window = Arc::new(
WindowBuilder::new()
.with_title("threers — normal-map")
.with_inner_size(winit::dpi::LogicalSize::new(800, 600))
.build(&event_loop)
.expect("window"),
);
let instance = {
let mut d = wgpu::InstanceDescriptor::new_without_display_handle();
d.backends = wgpu::Backends::PRIMARY;
wgpu::Instance::new(d)
};
let surface = instance.create_surface(window.clone()).expect("surface");
let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::default(),
compatible_surface: Some(&surface),
force_fallback_adapter: false,
apply_limit_buckets: false,
})
.await
.expect("adapter");
let adapter_limits = adapter.limits();
let mut limits = wgpu::Limits::downlevel_defaults().using_resolution(adapter_limits.clone());
limits.max_sampled_textures_per_shader_stage =
adapter_limits.max_sampled_textures_per_shader_stage;
limits.max_samplers_per_shader_stage = adapter_limits.max_samplers_per_shader_stage;
let (device, queue) = adapter
.request_device(
&wgpu::DeviceDescriptor {
label: Some("threers"),
required_features: wgpu::Features::empty(),
required_limits: limits,
..Default::default()
},
)
.await
.expect("device");
let device = Arc::new(device);
let queue = Arc::new(queue);
let size = window.inner_size();
let caps = surface.get_capabilities(&adapter);
let format = caps
.formats
.iter()
.copied()
.find(|f| f.is_srgb())
.unwrap_or(caps.formats[0]);
let mut config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format,
width: size.width.max(1),
height: size.height.max(1),
present_mode: caps.present_modes[0],
alpha_mode: caps.alpha_modes[0],
view_formats: vec![],
desired_maximum_frame_latency: 2,
color_space: wgpu::SurfaceColorSpace::Srgb,
};
surface.configure(&device, &config);
let mut renderer = Renderer::new(
device.clone(),
queue.clone(),
format,
config.width,
config.height,
);
let mut scene = Scene::new();
scene.background = Color::from_hex(0x0a0a0a);
scene.add_light(AmbientLight::new(Color::from_hex(0xffffff), 0.3));
let mut dl = Object3D::light(DirectionalLight::new(Color::from_hex(0xffffff), 1.0));
dl.position = Vector3::new(2.0, 3.0, 4.0);
scene.add(dl);
let tex_size: u32 = 16;
let mut data = vec![0u8; (tex_size * tex_size * 4) as usize];
for y in 0..tex_size {
for x in 0..tex_size {
let u = (x % 4) as f32 / 3.0 - 0.5;
let v = (y % 4) as f32 / 3.0 - 0.5;
let z = (1.0 - u * u - v * v).max(0.0).sqrt();
let i = ((y * tex_size + x) * 4) as usize;
data[i] = ((u * 0.5 + 0.5) * 255.0).round() as u8;
data[i + 1] = ((v * 0.5 + 0.5) * 255.0).round() as u8;
data[i + 2] = ((z * 0.5 + 0.5) * 255.0).round() as u8;
data[i + 3] = 255;
}
}
let normal_tex = Arc::new(DataTexture::new(
tex_size,
tex_size,
TextureFormat::Rgba8Unorm,
data,
));
let mat = StandardMaterial::new(Color::from_hex(0xaaaaaa))
.with_roughness(0.4)
.with_metalness(0.0)
.with_normal_map(normal_tex)
.into();
scene.add(Object3D::mesh(Mesh::new(
SphereGeometry::new(1.1, 48, 24),
mat,
)));
let mut camera = PerspectiveCamera::new(45.0, 800.0 / 600.0, 0.1, 100.0);
camera.position = Vector3::new(0.0, 0.0, 3.5);
camera.look_at(Vector3::ZERO);
scene.update_world();
let window_for_loop = window.clone();
event_loop
.run(move |event, target| match event {
Event::WindowEvent { event, window_id } if window_id == window_for_loop.id() => {
match event {
WindowEvent::CloseRequested => target.exit(),
WindowEvent::Resized(new_size) => {
config.width = new_size.width.max(1);
config.height = new_size.height.max(1);
surface.configure(&device, &config);
renderer.resize(config.width, config.height);
camera.set_aspect(config.width as f32 / config.height as f32);
}
WindowEvent::RedrawRequested => {
scene.update_world();
match surface.get_current_texture() {
wgpu::CurrentSurfaceTexture::Success(frame)
| wgpu::CurrentSurfaceTexture::Suboptimal(frame) => {
let view = frame
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
renderer.render(&mut scene, &camera, &view, false);
queue.present(frame);
}
wgpu::CurrentSurfaceTexture::Lost | wgpu::CurrentSurfaceTexture::Outdated => {
surface.configure(&device, &config);
}
e => log::error!("surface: {e:?}"),
}
}
_ => {}
}
}
Event::AboutToWait => window_for_loop.request_redraw(),
_ => {}
})
.expect("event loop");
}