Merge branch 'master' into update-tutorial2
@ -0,0 +1,44 @@
|
|||||||
|
[package]
|
||||||
|
name = "tutorial13-hdr"
|
||||||
|
version = "0.1.0"
|
||||||
|
authors = ["Ben Hansen (sotrh)"]
|
||||||
|
edition = "2018"
|
||||||
|
|
||||||
|
[lib]
|
||||||
|
crate-type = ["cdylib", "rlib"]
|
||||||
|
|
||||||
|
[dependencies]
|
||||||
|
cfg-if = "1"
|
||||||
|
anyhow = "1.0"
|
||||||
|
bytemuck = { version = "1.12", features = [ "derive" ] }
|
||||||
|
cgmath = "0.18"
|
||||||
|
env_logger = "0.10"
|
||||||
|
pollster = "0.3"
|
||||||
|
log = "0.4"
|
||||||
|
tobj = { version = "3.2", features = ["async"]}
|
||||||
|
wgpu = { version = "0.18"}
|
||||||
|
winit = "0.28"
|
||||||
|
instant = "0.1"
|
||||||
|
|
||||||
|
[dependencies.image]
|
||||||
|
version = "0.24"
|
||||||
|
default-features = false
|
||||||
|
features = ["png", "jpeg", "hdr"]
|
||||||
|
|
||||||
|
[target.'cfg(target_arch = "wasm32")'.dependencies]
|
||||||
|
reqwest = { version = "0.11" }
|
||||||
|
console_error_panic_hook = "0.1"
|
||||||
|
console_log = "1.0"
|
||||||
|
wasm-bindgen = "0.2"
|
||||||
|
wasm-bindgen-futures = "0.4"
|
||||||
|
web-sys = { version = "0.3", features = [
|
||||||
|
"Document",
|
||||||
|
"Window",
|
||||||
|
"Element",
|
||||||
|
"Location",
|
||||||
|
]}
|
||||||
|
|
||||||
|
[build-dependencies]
|
||||||
|
anyhow = "1.0"
|
||||||
|
fs_extra = "1.2"
|
||||||
|
glob = "0.3"
|
Before Width: | Height: | Size: 1.1 MiB After Width: | Height: | Size: 1.1 MiB |
Before Width: | Height: | Size: 2.1 MiB After Width: | Height: | Size: 2.1 MiB |
@ -0,0 +1,14 @@
|
|||||||
|
# Blender MTL File: 'cobble_sphere.blend'
|
||||||
|
# Material Count: 1
|
||||||
|
|
||||||
|
newmtl Material
|
||||||
|
Ns 250.000000
|
||||||
|
Ka 1.000000 1.000000 1.000000
|
||||||
|
Kd 0.800000 0.800000 0.800000
|
||||||
|
Ks 0.500000 0.500000 0.500000
|
||||||
|
Ke 0.000000 0.000000 0.000000
|
||||||
|
Ni 1.450000
|
||||||
|
d 1.000000
|
||||||
|
illum 2
|
||||||
|
map_Bump cobble-normal.png
|
||||||
|
map_Kd cobble-diffuse.png
|
Before Width: | Height: | Size: 25 KiB After Width: | Height: | Size: 25 KiB |
Before Width: | Height: | Size: 117 KiB After Width: | Height: | Size: 117 KiB |
@ -0,0 +1,13 @@
|
|||||||
|
# Blender 3.6.4 MTL File: 'floor.blend'
|
||||||
|
# www.blender.org
|
||||||
|
|
||||||
|
newmtl Material
|
||||||
|
Ns 250.000000
|
||||||
|
Ka 1.000000 1.000000 1.000000
|
||||||
|
Ks 0.500000 0.500000 0.500000
|
||||||
|
Ke 0.000000 0.000000 0.000000
|
||||||
|
Ni 1.450000
|
||||||
|
d 1.000000
|
||||||
|
illum 2
|
||||||
|
map_Kd cobble-diffuse.png
|
||||||
|
map_Bump cobble-normal.png
|
@ -0,0 +1,16 @@
|
|||||||
|
# Blender 3.6.4
|
||||||
|
# www.blender.org
|
||||||
|
mtllib floor.mtl
|
||||||
|
o Plane
|
||||||
|
v -1.000000 0.000000 1.000000
|
||||||
|
v 1.000000 0.000000 1.000000
|
||||||
|
v -1.000000 0.000000 -1.000000
|
||||||
|
v 1.000000 0.000000 -1.000000
|
||||||
|
vn -0.0000 1.0000 -0.0000
|
||||||
|
vt 0.000000 0.000000
|
||||||
|
vt 1.000000 0.000000
|
||||||
|
vt 1.000000 1.000000
|
||||||
|
vt 0.000000 1.000000
|
||||||
|
s 0
|
||||||
|
usemtl Material
|
||||||
|
f 1/1/1 2/2/1 4/3/1 3/4/1
|
@ -0,0 +1,189 @@
|
|||||||
|
use cgmath::*;
|
||||||
|
use std::f32::consts::FRAC_PI_2;
|
||||||
|
use std::time::Duration;
|
||||||
|
use winit::dpi::PhysicalPosition;
|
||||||
|
use winit::event::*;
|
||||||
|
|
||||||
|
const SAFE_FRAC_PI_2: f32 = FRAC_PI_2 - 0.0001;
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct Camera {
|
||||||
|
pub position: Point3<f32>,
|
||||||
|
yaw: Rad<f32>,
|
||||||
|
pitch: Rad<f32>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Camera {
|
||||||
|
pub fn new<V: Into<Point3<f32>>, Y: Into<Rad<f32>>, P: Into<Rad<f32>>>(
|
||||||
|
position: V,
|
||||||
|
yaw: Y,
|
||||||
|
pitch: P,
|
||||||
|
) -> Self {
|
||||||
|
Self {
|
||||||
|
position: position.into(),
|
||||||
|
yaw: yaw.into(),
|
||||||
|
pitch: pitch.into(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn calc_matrix(&self) -> Matrix4<f32> {
|
||||||
|
let (sin_pitch, cos_pitch) = self.pitch.0.sin_cos();
|
||||||
|
let (sin_yaw, cos_yaw) = self.yaw.0.sin_cos();
|
||||||
|
|
||||||
|
Matrix4::look_to_rh(
|
||||||
|
self.position,
|
||||||
|
Vector3::new(cos_pitch * cos_yaw, sin_pitch, cos_pitch * sin_yaw).normalize(),
|
||||||
|
Vector3::unit_y(),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub struct Projection {
|
||||||
|
aspect: f32,
|
||||||
|
fovy: Rad<f32>,
|
||||||
|
znear: f32,
|
||||||
|
zfar: f32,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Projection {
|
||||||
|
pub fn new<F: Into<Rad<f32>>>(width: u32, height: u32, fovy: F, znear: f32, zfar: f32) -> Self {
|
||||||
|
Self {
|
||||||
|
aspect: width as f32 / height as f32,
|
||||||
|
fovy: fovy.into(),
|
||||||
|
znear,
|
||||||
|
zfar,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn resize(&mut self, width: u32, height: u32) {
|
||||||
|
self.aspect = width as f32 / height as f32;
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn calc_matrix(&self) -> Matrix4<f32> {
|
||||||
|
// UDPATE
|
||||||
|
perspective(self.fovy, self.aspect, self.znear, self.zfar)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct CameraController {
|
||||||
|
amount_left: f32,
|
||||||
|
amount_right: f32,
|
||||||
|
amount_forward: f32,
|
||||||
|
amount_backward: f32,
|
||||||
|
amount_up: f32,
|
||||||
|
amount_down: f32,
|
||||||
|
rotate_horizontal: f32,
|
||||||
|
rotate_vertical: f32,
|
||||||
|
scroll: f32,
|
||||||
|
speed: f32,
|
||||||
|
sensitivity: f32,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl CameraController {
|
||||||
|
pub fn new(speed: f32, sensitivity: f32) -> Self {
|
||||||
|
Self {
|
||||||
|
amount_left: 0.0,
|
||||||
|
amount_right: 0.0,
|
||||||
|
amount_forward: 0.0,
|
||||||
|
amount_backward: 0.0,
|
||||||
|
amount_up: 0.0,
|
||||||
|
amount_down: 0.0,
|
||||||
|
rotate_horizontal: 0.0,
|
||||||
|
rotate_vertical: 0.0,
|
||||||
|
scroll: 0.0,
|
||||||
|
speed,
|
||||||
|
sensitivity,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn process_keyboard(&mut self, key: VirtualKeyCode, state: ElementState) -> bool {
|
||||||
|
let amount = if state == ElementState::Pressed {
|
||||||
|
1.0
|
||||||
|
} else {
|
||||||
|
0.0
|
||||||
|
};
|
||||||
|
match key {
|
||||||
|
VirtualKeyCode::W | VirtualKeyCode::Up => {
|
||||||
|
self.amount_forward = amount;
|
||||||
|
true
|
||||||
|
}
|
||||||
|
VirtualKeyCode::S | VirtualKeyCode::Down => {
|
||||||
|
self.amount_backward = amount;
|
||||||
|
true
|
||||||
|
}
|
||||||
|
VirtualKeyCode::A | VirtualKeyCode::Left => {
|
||||||
|
self.amount_left = amount;
|
||||||
|
true
|
||||||
|
}
|
||||||
|
VirtualKeyCode::D | VirtualKeyCode::Right => {
|
||||||
|
self.amount_right = amount;
|
||||||
|
true
|
||||||
|
}
|
||||||
|
VirtualKeyCode::Space => {
|
||||||
|
self.amount_up = amount;
|
||||||
|
true
|
||||||
|
}
|
||||||
|
VirtualKeyCode::LShift => {
|
||||||
|
self.amount_down = amount;
|
||||||
|
true
|
||||||
|
}
|
||||||
|
_ => false,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn process_mouse(&mut self, mouse_dx: f64, mouse_dy: f64) {
|
||||||
|
self.rotate_horizontal = mouse_dx as f32;
|
||||||
|
self.rotate_vertical = mouse_dy as f32;
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn process_scroll(&mut self, delta: &MouseScrollDelta) {
|
||||||
|
self.scroll = match delta {
|
||||||
|
// I'm assuming a line is about 100 pixels
|
||||||
|
MouseScrollDelta::LineDelta(_, scroll) => -scroll * 0.5,
|
||||||
|
MouseScrollDelta::PixelDelta(PhysicalPosition { y: scroll, .. }) => -*scroll as f32,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn update_camera(&mut self, camera: &mut Camera, dt: Duration) {
|
||||||
|
let dt = dt.as_secs_f32();
|
||||||
|
|
||||||
|
// Move forward/backward and left/right
|
||||||
|
let (yaw_sin, yaw_cos) = camera.yaw.0.sin_cos();
|
||||||
|
let forward = Vector3::new(yaw_cos, 0.0, yaw_sin).normalize();
|
||||||
|
let right = Vector3::new(-yaw_sin, 0.0, yaw_cos).normalize();
|
||||||
|
camera.position += forward * (self.amount_forward - self.amount_backward) * self.speed * dt;
|
||||||
|
camera.position += right * (self.amount_right - self.amount_left) * self.speed * dt;
|
||||||
|
|
||||||
|
// Move in/out (aka. "zoom")
|
||||||
|
// Note: this isn't an actual zoom. The camera's position
|
||||||
|
// changes when zooming. I've added this to make it easier
|
||||||
|
// to get closer to an object you want to focus on.
|
||||||
|
let (pitch_sin, pitch_cos) = camera.pitch.0.sin_cos();
|
||||||
|
let scrollward =
|
||||||
|
Vector3::new(pitch_cos * yaw_cos, pitch_sin, pitch_cos * yaw_sin).normalize();
|
||||||
|
camera.position += scrollward * self.scroll * self.speed * self.sensitivity * dt;
|
||||||
|
self.scroll = 0.0;
|
||||||
|
|
||||||
|
// Move up/down. Since we don't use roll, we can just
|
||||||
|
// modify the y coordinate directly.
|
||||||
|
camera.position.y += (self.amount_up - self.amount_down) * self.speed * dt;
|
||||||
|
|
||||||
|
// Rotate
|
||||||
|
camera.yaw += Rad(self.rotate_horizontal) * self.sensitivity * dt;
|
||||||
|
camera.pitch += Rad(-self.rotate_vertical) * self.sensitivity * dt;
|
||||||
|
|
||||||
|
// If process_mouse isn't called every frame, these values
|
||||||
|
// will not get set to zero, and the camera will rotate
|
||||||
|
// when moving in a non cardinal direction.
|
||||||
|
self.rotate_horizontal = 0.0;
|
||||||
|
self.rotate_vertical = 0.0;
|
||||||
|
|
||||||
|
// Keep the camera's angle from going too high/low.
|
||||||
|
if camera.pitch < -Rad(SAFE_FRAC_PI_2) {
|
||||||
|
camera.pitch = -Rad(SAFE_FRAC_PI_2);
|
||||||
|
} else if camera.pitch > Rad(SAFE_FRAC_PI_2) {
|
||||||
|
camera.pitch = Rad(SAFE_FRAC_PI_2);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
@ -0,0 +1,99 @@
|
|||||||
|
use std::mem::size_of;
|
||||||
|
|
||||||
|
use wgpu::util::{BufferInitDescriptor, DeviceExt};
|
||||||
|
|
||||||
|
use crate::create_render_pipeline;
|
||||||
|
|
||||||
|
#[repr(C)]
|
||||||
|
#[derive(Debug, Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
|
||||||
|
pub struct PositionColor {
|
||||||
|
position: [f32; 3],
|
||||||
|
color: [f32; 3],
|
||||||
|
}
|
||||||
|
|
||||||
|
const AXIS_COLORS: &'static [PositionColor] = &[
|
||||||
|
// X
|
||||||
|
PositionColor {
|
||||||
|
position: [0.0, 0.0, 0.0],
|
||||||
|
color: [0.5, 0.0, 0.0],
|
||||||
|
},
|
||||||
|
PositionColor {
|
||||||
|
position: [1.0, 0.0, 0.0],
|
||||||
|
color: [1.0, 0.0, 0.0],
|
||||||
|
},
|
||||||
|
// Y
|
||||||
|
PositionColor {
|
||||||
|
position: [0.0, 0.0, 0.0],
|
||||||
|
color: [0.0, 0.5, 0.0],
|
||||||
|
},
|
||||||
|
PositionColor {
|
||||||
|
position: [0.0, 1.0, 0.0],
|
||||||
|
color: [0.0, 1.0, 0.0],
|
||||||
|
},
|
||||||
|
// Z
|
||||||
|
PositionColor {
|
||||||
|
position: [0.0, 0.0, 0.0],
|
||||||
|
color: [0.0, 0.0, 0.5],
|
||||||
|
},
|
||||||
|
PositionColor {
|
||||||
|
position: [0.0, 0.0, 1.0],
|
||||||
|
color: [0.0, 0.0, 1.0],
|
||||||
|
},
|
||||||
|
];
|
||||||
|
|
||||||
|
const POSITION_COLOR_LAYOUT: wgpu::VertexBufferLayout<'static> = wgpu::VertexBufferLayout {
|
||||||
|
array_stride: size_of::<PositionColor>() as _,
|
||||||
|
step_mode: wgpu::VertexStepMode::Vertex,
|
||||||
|
attributes: &wgpu::vertex_attr_array![
|
||||||
|
0 => Float32x3,
|
||||||
|
1 => Float32x3,
|
||||||
|
],
|
||||||
|
};
|
||||||
|
|
||||||
|
pub struct Debug {
|
||||||
|
color_lines: wgpu::RenderPipeline,
|
||||||
|
axis: wgpu::Buffer,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Debug {
|
||||||
|
pub fn new(
|
||||||
|
device: &wgpu::Device,
|
||||||
|
camera_layout: &wgpu::BindGroupLayout,
|
||||||
|
color_format: wgpu::TextureFormat,
|
||||||
|
) -> Self {
|
||||||
|
let axis = device.create_buffer_init(&BufferInitDescriptor {
|
||||||
|
label: Some("Debug::axis"),
|
||||||
|
contents: bytemuck::cast_slice(AXIS_COLORS),
|
||||||
|
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::VERTEX,
|
||||||
|
});
|
||||||
|
|
||||||
|
let shader = wgpu::include_wgsl!("debug.wgsl");
|
||||||
|
let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
||||||
|
label: None,
|
||||||
|
bind_group_layouts: &[camera_layout],
|
||||||
|
push_constant_ranges: &[],
|
||||||
|
});
|
||||||
|
let color_lines = create_render_pipeline(
|
||||||
|
device,
|
||||||
|
&layout,
|
||||||
|
color_format,
|
||||||
|
None,
|
||||||
|
&[POSITION_COLOR_LAYOUT],
|
||||||
|
wgpu::PrimitiveTopology::LineList,
|
||||||
|
shader,
|
||||||
|
);
|
||||||
|
|
||||||
|
Self { color_lines, axis }
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn draw_axis<'a: 'b, 'b>(
|
||||||
|
&'a self,
|
||||||
|
pass: &'b mut wgpu::RenderPass<'a>,
|
||||||
|
camera: &'a wgpu::BindGroup,
|
||||||
|
) {
|
||||||
|
pass.set_pipeline(&self.color_lines);
|
||||||
|
pass.set_bind_group(0, camera, &[]);
|
||||||
|
pass.set_vertex_buffer(0, self.axis.slice(..));
|
||||||
|
pass.draw(0..AXIS_COLORS.len() as u32, 0..1);
|
||||||
|
}
|
||||||
|
}
|
@ -0,0 +1,34 @@
|
|||||||
|
struct Camera {
|
||||||
|
view_pos: vec4<f32>,
|
||||||
|
view: mat4x4<f32>,
|
||||||
|
view_proj: mat4x4<f32>,
|
||||||
|
inv_proj: mat4x4<f32>,
|
||||||
|
inv_view: mat4x4<f32>,
|
||||||
|
}
|
||||||
|
@group(0) @binding(0)
|
||||||
|
var<uniform> camera: Camera;
|
||||||
|
|
||||||
|
struct PositionColor {
|
||||||
|
@location(0) position: vec3<f32>,
|
||||||
|
@location(1) color: vec3<f32>,
|
||||||
|
}
|
||||||
|
|
||||||
|
struct VsOut {
|
||||||
|
@builtin(position) frag_position: vec4<f32>,
|
||||||
|
@location(0) color: vec3<f32>,
|
||||||
|
}
|
||||||
|
|
||||||
|
@vertex
|
||||||
|
fn vs_main(
|
||||||
|
v: PositionColor,
|
||||||
|
) -> VsOut {
|
||||||
|
let frag_position = camera.view_proj * vec4(v.position, 1.0);
|
||||||
|
return VsOut(frag_position, v.color);
|
||||||
|
}
|
||||||
|
|
||||||
|
@fragment
|
||||||
|
fn fs_main(
|
||||||
|
v: VsOut,
|
||||||
|
) -> @location(0) vec4<f32> {
|
||||||
|
return vec4(v.color, 1.0);
|
||||||
|
}
|
@ -0,0 +1,87 @@
|
|||||||
|
const PI: f32 = 3.1415926535897932384626433832795;
|
||||||
|
|
||||||
|
struct Face {
|
||||||
|
forward: vec3<f32>,
|
||||||
|
up: vec3<f32>,
|
||||||
|
right: vec3<f32>,
|
||||||
|
}
|
||||||
|
|
||||||
|
@group(0)
|
||||||
|
@binding(0)
|
||||||
|
var src: texture_2d<f32>;
|
||||||
|
|
||||||
|
@group(0)
|
||||||
|
@binding(1)
|
||||||
|
var dst: texture_storage_2d_array<rgba32float, write>;
|
||||||
|
|
||||||
|
|
||||||
|
@compute
|
||||||
|
@workgroup_size(16, 16, 1)
|
||||||
|
fn compute_equirect_to_cubemap(
|
||||||
|
@builtin(global_invocation_id)
|
||||||
|
gid: vec3<u32>,
|
||||||
|
) {
|
||||||
|
// If texture size is not divisible by 32 we
|
||||||
|
// need to make sure we don't try to write to
|
||||||
|
// pixels that don't exist.
|
||||||
|
if gid.x >= u32(textureDimensions(dst).x) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
var FACES: array<Face, 6> = array(
|
||||||
|
// FACES +X
|
||||||
|
Face(
|
||||||
|
vec3(1.0, 0.0, 0.0), // forward
|
||||||
|
vec3(0.0, 1.0, 0.0), // up
|
||||||
|
vec3(0.0, 0.0, -1.0), // right
|
||||||
|
),
|
||||||
|
// FACES -X
|
||||||
|
Face (
|
||||||
|
vec3(-1.0, 0.0, 0.0),
|
||||||
|
vec3(0.0, 1.0, 0.0),
|
||||||
|
vec3(0.0, 0.0, 1.0),
|
||||||
|
),
|
||||||
|
// FACES +Y
|
||||||
|
Face (
|
||||||
|
vec3(0.0, -1.0, 0.0),
|
||||||
|
vec3(0.0, 0.0, 1.0),
|
||||||
|
vec3(1.0, 0.0, 0.0),
|
||||||
|
),
|
||||||
|
// FACES -Y
|
||||||
|
Face (
|
||||||
|
vec3(0.0, 1.0, 0.0),
|
||||||
|
vec3(0.0, 0.0, -1.0),
|
||||||
|
vec3(1.0, 0.0, 0.0),
|
||||||
|
),
|
||||||
|
// FACES +Z
|
||||||
|
Face (
|
||||||
|
vec3(0.0, 0.0, 1.0),
|
||||||
|
vec3(0.0, 1.0, 0.0),
|
||||||
|
vec3(1.0, 0.0, 0.0),
|
||||||
|
),
|
||||||
|
// FACES -Z
|
||||||
|
Face (
|
||||||
|
vec3(0.0, 0.0, -1.0),
|
||||||
|
vec3(0.0, 1.0, 0.0),
|
||||||
|
vec3(-1.0, 0.0, 0.0),
|
||||||
|
),
|
||||||
|
);
|
||||||
|
|
||||||
|
// Get texture coords relative to cubemap face
|
||||||
|
let dst_dimensions = vec2<f32>(textureDimensions(dst));
|
||||||
|
let cube_uv = vec2<f32>(gid.xy) / dst_dimensions * 2.0 - 1.0;
|
||||||
|
|
||||||
|
// Get spherical coordinate from cube_uv
|
||||||
|
let face = FACES[gid.z];
|
||||||
|
let spherical = normalize(face.forward + face.right * cube_uv.x + face.up * cube_uv.y);
|
||||||
|
|
||||||
|
// Get coordinate on the equirectangular texture
|
||||||
|
let inv_atan = vec2(0.1591, 0.3183);
|
||||||
|
let eq_uv = vec2(atan2(spherical.z, spherical.x), asin(spherical.y)) * inv_atan + 0.5;
|
||||||
|
let eq_pixel = vec2<i32>(eq_uv * vec2<f32>(textureDimensions(src)));
|
||||||
|
|
||||||
|
// We use textureLoad() as textureSample() is not allowed in compute shaders
|
||||||
|
var sample = textureLoad(src, eq_pixel, 0);
|
||||||
|
|
||||||
|
textureStore(dst, gid.xy, gid.z, sample);
|
||||||
|
}
|
@ -0,0 +1,160 @@
|
|||||||
|
use wgpu::Operations;
|
||||||
|
|
||||||
|
use crate::{create_render_pipeline, texture};
|
||||||
|
|
||||||
|
/// Owns the render texture and controls tonemapping
|
||||||
|
pub struct HdrPipeline {
|
||||||
|
pipeline: wgpu::RenderPipeline,
|
||||||
|
bind_group: wgpu::BindGroup,
|
||||||
|
texture: texture::Texture,
|
||||||
|
width: u32,
|
||||||
|
height: u32,
|
||||||
|
format: wgpu::TextureFormat,
|
||||||
|
layout: wgpu::BindGroupLayout,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl HdrPipeline {
|
||||||
|
pub fn new(device: &wgpu::Device, config: &wgpu::SurfaceConfiguration) -> Self {
|
||||||
|
let width = config.width;
|
||||||
|
let height = config.height;
|
||||||
|
|
||||||
|
// We could use `Rgba32Float`, but that requires some extra
|
||||||
|
// features to be enabled.
|
||||||
|
let format = wgpu::TextureFormat::Rgba16Float;
|
||||||
|
|
||||||
|
let texture = texture::Texture::create_2d_texture(
|
||||||
|
device,
|
||||||
|
width,
|
||||||
|
height,
|
||||||
|
format,
|
||||||
|
wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::RENDER_ATTACHMENT,
|
||||||
|
wgpu::FilterMode::Nearest,
|
||||||
|
Some("Hdr::texture"),
|
||||||
|
);
|
||||||
|
|
||||||
|
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
||||||
|
label: Some("Hdr::layout"),
|
||||||
|
entries: &[
|
||||||
|
wgpu::BindGroupLayoutEntry {
|
||||||
|
binding: 0,
|
||||||
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
||||||
|
ty: wgpu::BindingType::Texture {
|
||||||
|
// The Rgba16Float format cannot be filtered
|
||||||
|
sample_type: wgpu::TextureSampleType::Float { filterable: true },
|
||||||
|
view_dimension: wgpu::TextureViewDimension::D2,
|
||||||
|
multisampled: false,
|
||||||
|
},
|
||||||
|
count: None,
|
||||||
|
},
|
||||||
|
wgpu::BindGroupLayoutEntry {
|
||||||
|
binding: 1,
|
||||||
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
||||||
|
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
|
||||||
|
count: None,
|
||||||
|
},
|
||||||
|
],
|
||||||
|
});
|
||||||
|
let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
|
||||||
|
label: Some("Hdr::bind_group"),
|
||||||
|
layout: &layout,
|
||||||
|
entries: &[
|
||||||
|
wgpu::BindGroupEntry {
|
||||||
|
binding: 0,
|
||||||
|
resource: wgpu::BindingResource::TextureView(&texture.view),
|
||||||
|
},
|
||||||
|
wgpu::BindGroupEntry {
|
||||||
|
binding: 1,
|
||||||
|
resource: wgpu::BindingResource::Sampler(&texture.sampler),
|
||||||
|
},
|
||||||
|
],
|
||||||
|
});
|
||||||
|
|
||||||
|
let shader = wgpu::include_wgsl!("hdr.wgsl");
|
||||||
|
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
||||||
|
label: None,
|
||||||
|
bind_group_layouts: &[&layout],
|
||||||
|
push_constant_ranges: &[],
|
||||||
|
});
|
||||||
|
|
||||||
|
let pipeline = create_render_pipeline(
|
||||||
|
device,
|
||||||
|
&pipeline_layout,
|
||||||
|
config.format,
|
||||||
|
None,
|
||||||
|
&[],
|
||||||
|
wgpu::PrimitiveTopology::TriangleList,
|
||||||
|
shader,
|
||||||
|
);
|
||||||
|
|
||||||
|
Self {
|
||||||
|
pipeline,
|
||||||
|
bind_group,
|
||||||
|
layout,
|
||||||
|
texture,
|
||||||
|
width,
|
||||||
|
height,
|
||||||
|
format,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Resize the HDR texture
|
||||||
|
pub fn resize(&mut self, device: &wgpu::Device, width: u32, height: u32) {
|
||||||
|
self.texture = texture::Texture::create_2d_texture(
|
||||||
|
device,
|
||||||
|
width,
|
||||||
|
height,
|
||||||
|
wgpu::TextureFormat::Rgba16Float,
|
||||||
|
wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::RENDER_ATTACHMENT,
|
||||||
|
wgpu::FilterMode::Nearest,
|
||||||
|
Some("Hdr::texture"),
|
||||||
|
);
|
||||||
|
self.bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
|
||||||
|
label: Some("Hdr::bind_group"),
|
||||||
|
layout: &self.layout,
|
||||||
|
entries: &[
|
||||||
|
wgpu::BindGroupEntry {
|
||||||
|
binding: 0,
|
||||||
|
resource: wgpu::BindingResource::TextureView(&self.texture.view),
|
||||||
|
},
|
||||||
|
wgpu::BindGroupEntry {
|
||||||
|
binding: 1,
|
||||||
|
resource: wgpu::BindingResource::Sampler(&self.texture.sampler),
|
||||||
|
},
|
||||||
|
],
|
||||||
|
});
|
||||||
|
self.width = width;
|
||||||
|
self.height = height;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Exposes the HDR texture
|
||||||
|
pub fn view(&self) -> &wgpu::TextureView {
|
||||||
|
&self.texture.view
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The format of the HDR texture
|
||||||
|
pub fn format(&self) -> wgpu::TextureFormat {
|
||||||
|
self.format
|
||||||
|
}
|
||||||
|
|
||||||
|
/// This renders the internal HDR texture to the [TextureView]
|
||||||
|
/// supplied as parameter.
|
||||||
|
pub fn process(&self, encoder: &mut wgpu::CommandEncoder, output: &wgpu::TextureView) {
|
||||||
|
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
||||||
|
label: Some("Hdr::process"),
|
||||||
|
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
|
||||||
|
view: &output,
|
||||||
|
resolve_target: None,
|
||||||
|
ops: Operations {
|
||||||
|
load: wgpu::LoadOp::Load,
|
||||||
|
store: wgpu::StoreOp::Store,
|
||||||
|
},
|
||||||
|
})],
|
||||||
|
depth_stencil_attachment: None,
|
||||||
|
occlusion_query_set: None,
|
||||||
|
timestamp_writes: None,
|
||||||
|
});
|
||||||
|
pass.set_pipeline(&self.pipeline);
|
||||||
|
pass.set_bind_group(0, &self.bind_group, &[]);
|
||||||
|
pass.draw(0..3, 0..1);
|
||||||
|
}
|
||||||
|
}
|
@ -0,0 +1,55 @@
|
|||||||
|
// Maps HDR values to linear values
|
||||||
|
// Based on http://www.oscars.org/science-technology/sci-tech-projects/aces
|
||||||
|
fn aces_tone_map(hdr: vec3<f32>) -> vec3<f32> {
|
||||||
|
let m1 = mat3x3(
|
||||||
|
0.59719, 0.07600, 0.02840,
|
||||||
|
0.35458, 0.90834, 0.13383,
|
||||||
|
0.04823, 0.01566, 0.83777,
|
||||||
|
);
|
||||||
|
let m2 = mat3x3(
|
||||||
|
1.60475, -0.10208, -0.00327,
|
||||||
|
-0.53108, 1.10813, -0.07276,
|
||||||
|
-0.07367, -0.00605, 1.07602,
|
||||||
|
);
|
||||||
|
let v = m1 * hdr;
|
||||||
|
let a = v * (v + 0.0245786) - 0.000090537;
|
||||||
|
let b = v * (0.983729 * v + 0.4329510) + 0.238081;
|
||||||
|
return clamp(m2 * (a / b), vec3(0.0), vec3(1.0));
|
||||||
|
}
|
||||||
|
|
||||||
|
struct VertexOutput {
|
||||||
|
@location(0) uv: vec2<f32>,
|
||||||
|
@builtin(position) clip_position: vec4<f32>,
|
||||||
|
};
|
||||||
|
|
||||||
|
@vertex
|
||||||
|
fn vs_main(
|
||||||
|
@builtin(vertex_index) vi: u32,
|
||||||
|
) -> VertexOutput {
|
||||||
|
var out: VertexOutput;
|
||||||
|
// Generate a triangle that covers the whole screen
|
||||||
|
out.uv = vec2<f32>(
|
||||||
|
f32((vi << 1u) & 2u),
|
||||||
|
f32(vi & 2u),
|
||||||
|
);
|
||||||
|
out.clip_position = vec4<f32>(out.uv * 2.0 - 1.0, 0.0, 1.0);
|
||||||
|
// We need to invert the y coordinate so the image
|
||||||
|
// is not upside down
|
||||||
|
out.uv.y = 1.0 - out.uv.y;
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
|
||||||
|
@group(0)
|
||||||
|
@binding(0)
|
||||||
|
var hdr_image: texture_2d<f32>;
|
||||||
|
|
||||||
|
@group(0)
|
||||||
|
@binding(1)
|
||||||
|
var hdr_sampler: sampler;
|
||||||
|
|
||||||
|
@fragment
|
||||||
|
fn fs_main(vs: VertexOutput) -> @location(0) vec4<f32> {
|
||||||
|
let hdr = textureSample(hdr_image, hdr_sampler, vs.uv);
|
||||||
|
let sdr = aces_tone_map(hdr.rgb);
|
||||||
|
return vec4(sdr, hdr.a);
|
||||||
|
}
|
@ -0,0 +1,902 @@
|
|||||||
|
use std::iter;
|
||||||
|
|
||||||
|
use cgmath::prelude::*;
|
||||||
|
use wgpu::util::DeviceExt;
|
||||||
|
use winit::{
|
||||||
|
event::*,
|
||||||
|
event_loop::{ControlFlow, EventLoop},
|
||||||
|
window::Window,
|
||||||
|
};
|
||||||
|
|
||||||
|
#[cfg(target_arch = "wasm32")]
|
||||||
|
use wasm_bindgen::prelude::*;
|
||||||
|
|
||||||
|
mod camera;
|
||||||
|
mod hdr;
|
||||||
|
mod model;
|
||||||
|
mod resources;
|
||||||
|
mod texture;
|
||||||
|
|
||||||
|
#[cfg(feature = "debug")]
|
||||||
|
mod debug;
|
||||||
|
|
||||||
|
use model::{DrawLight, DrawModel, Vertex};
|
||||||
|
|
||||||
|
const NUM_INSTANCES_PER_ROW: u32 = 10;
|
||||||
|
|
||||||
|
#[repr(C)]
|
||||||
|
#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
|
||||||
|
struct CameraUniform {
|
||||||
|
view_position: [f32; 4],
|
||||||
|
view: [[f32; 4]; 4], // NEW!
|
||||||
|
view_proj: [[f32; 4]; 4],
|
||||||
|
inv_proj: [[f32; 4]; 4], // NEW!
|
||||||
|
inv_view: [[f32; 4]; 4], // NEW!
|
||||||
|
}
|
||||||
|
|
||||||
|
impl CameraUniform {
|
||||||
|
fn new() -> Self {
|
||||||
|
Self {
|
||||||
|
view_position: [0.0; 4],
|
||||||
|
view: cgmath::Matrix4::identity().into(), // NEW!
|
||||||
|
view_proj: cgmath::Matrix4::identity().into(),
|
||||||
|
inv_proj: cgmath::Matrix4::identity().into(), // NEW!
|
||||||
|
inv_view: cgmath::Matrix4::identity().into(), // NEW!
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// UPDATED!
|
||||||
|
fn update_view_proj(&mut self, camera: &camera::Camera, projection: &camera::Projection) {
|
||||||
|
self.view_position = camera.position.to_homogeneous().into();
|
||||||
|
let proj = projection.calc_matrix();
|
||||||
|
let view = camera.calc_matrix();
|
||||||
|
let view_proj = proj * view;
|
||||||
|
self.view = view.into();
|
||||||
|
self.view_proj = view_proj.into();
|
||||||
|
self.inv_proj = proj.invert().unwrap().into();
|
||||||
|
self.inv_view = view.transpose().into();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
struct Instance {
|
||||||
|
position: cgmath::Vector3<f32>,
|
||||||
|
rotation: cgmath::Quaternion<f32>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Instance {
|
||||||
|
fn to_raw(&self) -> InstanceRaw {
|
||||||
|
InstanceRaw {
|
||||||
|
model: (cgmath::Matrix4::from_translation(self.position)
|
||||||
|
* cgmath::Matrix4::from(self.rotation))
|
||||||
|
.into(),
|
||||||
|
normal: cgmath::Matrix3::from(self.rotation).into(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[repr(C)]
|
||||||
|
#[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
|
||||||
|
#[allow(dead_code)]
|
||||||
|
struct InstanceRaw {
|
||||||
|
model: [[f32; 4]; 4],
|
||||||
|
normal: [[f32; 3]; 3],
|
||||||
|
}
|
||||||
|
|
||||||
|
impl model::Vertex for InstanceRaw {
|
||||||
|
fn desc() -> wgpu::VertexBufferLayout<'static> {
|
||||||
|
use std::mem;
|
||||||
|
wgpu::VertexBufferLayout {
|
||||||
|
array_stride: mem::size_of::<InstanceRaw>() as wgpu::BufferAddress,
|
||||||
|
// We need to switch from using a step mode of Vertex to Instance
|
||||||
|
// This means that our shaders will only change to use the next
|
||||||
|
// instance when the shader starts processing a new instance
|
||||||
|
step_mode: wgpu::VertexStepMode::Instance,
|
||||||
|
attributes: &[
|
||||||
|
wgpu::VertexAttribute {
|
||||||
|
offset: 0,
|
||||||
|
// While our vertex shader only uses locations 0, and 1 now, in later tutorials we'll
|
||||||
|
// be using 2, 3, and 4, for Vertex. We'll start at slot 5 not conflict with them later
|
||||||
|
shader_location: 5,
|
||||||
|
format: wgpu::VertexFormat::Float32x4,
|
||||||
|
},
|
||||||
|
// A mat4 takes up 4 vertex slots as it is technically 4 vec4s. We need to define a slot
|
||||||
|
// for each vec4. We don't have to do this in code though.
|
||||||
|
wgpu::VertexAttribute {
|
||||||
|
offset: mem::size_of::<[f32; 4]>() as wgpu::BufferAddress,
|
||||||
|
shader_location: 6,
|
||||||
|
format: wgpu::VertexFormat::Float32x4,
|
||||||
|
},
|
||||||
|
wgpu::VertexAttribute {
|
||||||
|
offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress,
|
||||||
|
shader_location: 7,
|
||||||
|
format: wgpu::VertexFormat::Float32x4,
|
||||||
|
},
|
||||||
|
wgpu::VertexAttribute {
|
||||||
|
offset: mem::size_of::<[f32; 12]>() as wgpu::BufferAddress,
|
||||||
|
shader_location: 8,
|
||||||
|
format: wgpu::VertexFormat::Float32x4,
|
||||||
|
},
|
||||||
|
wgpu::VertexAttribute {
|
||||||
|
offset: mem::size_of::<[f32; 16]>() as wgpu::BufferAddress,
|
||||||
|
shader_location: 9,
|
||||||
|
format: wgpu::VertexFormat::Float32x3,
|
||||||
|
},
|
||||||
|
wgpu::VertexAttribute {
|
||||||
|
offset: mem::size_of::<[f32; 19]>() as wgpu::BufferAddress,
|
||||||
|
shader_location: 10,
|
||||||
|
format: wgpu::VertexFormat::Float32x3,
|
||||||
|
},
|
||||||
|
wgpu::VertexAttribute {
|
||||||
|
offset: mem::size_of::<[f32; 22]>() as wgpu::BufferAddress,
|
||||||
|
shader_location: 11,
|
||||||
|
format: wgpu::VertexFormat::Float32x3,
|
||||||
|
},
|
||||||
|
],
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[repr(C)]
|
||||||
|
#[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
|
||||||
|
struct LightUniform {
|
||||||
|
position: [f32; 3],
|
||||||
|
// Due to uniforms requiring 16 byte (4 float) spacing, we need to use a padding field here
|
||||||
|
_padding: u32,
|
||||||
|
color: [f32; 3],
|
||||||
|
_padding2: u32,
|
||||||
|
}
|
||||||
|
|
||||||
|
struct State {
|
||||||
|
window: Window,
|
||||||
|
surface: wgpu::Surface,
|
||||||
|
device: wgpu::Device,
|
||||||
|
queue: wgpu::Queue,
|
||||||
|
config: wgpu::SurfaceConfiguration,
|
||||||
|
render_pipeline: wgpu::RenderPipeline,
|
||||||
|
obj_model: model::Model,
|
||||||
|
camera: camera::Camera,
|
||||||
|
projection: camera::Projection,
|
||||||
|
camera_controller: camera::CameraController,
|
||||||
|
camera_uniform: CameraUniform,
|
||||||
|
camera_buffer: wgpu::Buffer,
|
||||||
|
camera_bind_group: wgpu::BindGroup,
|
||||||
|
instances: Vec<Instance>,
|
||||||
|
#[allow(dead_code)]
|
||||||
|
instance_buffer: wgpu::Buffer,
|
||||||
|
depth_texture: texture::Texture,
|
||||||
|
size: winit::dpi::PhysicalSize<u32>,
|
||||||
|
light_uniform: LightUniform,
|
||||||
|
light_buffer: wgpu::Buffer,
|
||||||
|
light_bind_group: wgpu::BindGroup,
|
||||||
|
light_render_pipeline: wgpu::RenderPipeline,
|
||||||
|
#[allow(dead_code)]
|
||||||
|
debug_material: model::Material,
|
||||||
|
mouse_pressed: bool,
|
||||||
|
// NEW!
|
||||||
|
hdr: hdr::HdrPipeline,
|
||||||
|
environment_bind_group: wgpu::BindGroup,
|
||||||
|
sky_pipeline: wgpu::RenderPipeline,
|
||||||
|
#[cfg(feature = "debug")]
|
||||||
|
debug: debug::Debug,
|
||||||
|
}
|
||||||
|
|
||||||
|
fn create_render_pipeline(
|
||||||
|
device: &wgpu::Device,
|
||||||
|
layout: &wgpu::PipelineLayout,
|
||||||
|
color_format: wgpu::TextureFormat,
|
||||||
|
depth_format: Option<wgpu::TextureFormat>,
|
||||||
|
vertex_layouts: &[wgpu::VertexBufferLayout],
|
||||||
|
topology: wgpu::PrimitiveTopology, // NEW!
|
||||||
|
shader: wgpu::ShaderModuleDescriptor,
|
||||||
|
) -> wgpu::RenderPipeline {
|
||||||
|
let shader = device.create_shader_module(shader);
|
||||||
|
|
||||||
|
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
|
||||||
|
label: Some(&format!("{:?}", shader)),
|
||||||
|
layout: Some(layout),
|
||||||
|
vertex: wgpu::VertexState {
|
||||||
|
module: &shader,
|
||||||
|
entry_point: "vs_main",
|
||||||
|
buffers: vertex_layouts,
|
||||||
|
},
|
||||||
|
fragment: Some(wgpu::FragmentState {
|
||||||
|
module: &shader,
|
||||||
|
entry_point: "fs_main",
|
||||||
|
targets: &[Some(wgpu::ColorTargetState {
|
||||||
|
format: color_format,
|
||||||
|
blend: None,
|
||||||
|
write_mask: wgpu::ColorWrites::ALL,
|
||||||
|
})],
|
||||||
|
}),
|
||||||
|
primitive: wgpu::PrimitiveState {
|
||||||
|
topology, // NEW!
|
||||||
|
strip_index_format: None,
|
||||||
|
front_face: wgpu::FrontFace::Ccw,
|
||||||
|
cull_mode: Some(wgpu::Face::Back),
|
||||||
|
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
|
||||||
|
polygon_mode: wgpu::PolygonMode::Fill,
|
||||||
|
// Requires Features::DEPTH_CLIP_CONTROL
|
||||||
|
unclipped_depth: false,
|
||||||
|
// Requires Features::CONSERVATIVE_RASTERIZATION
|
||||||
|
conservative: false,
|
||||||
|
},
|
||||||
|
depth_stencil: depth_format.map(|format| wgpu::DepthStencilState {
|
||||||
|
format,
|
||||||
|
depth_write_enabled: true,
|
||||||
|
depth_compare: wgpu::CompareFunction::LessEqual, // UDPATED!
|
||||||
|
stencil: wgpu::StencilState::default(),
|
||||||
|
bias: wgpu::DepthBiasState::default(),
|
||||||
|
}),
|
||||||
|
multisample: wgpu::MultisampleState {
|
||||||
|
count: 1,
|
||||||
|
mask: !0,
|
||||||
|
alpha_to_coverage_enabled: false,
|
||||||
|
},
|
||||||
|
// If the pipeline will be used with a multiview render pass, this
|
||||||
|
// indicates how many array layers the attachments will have.
|
||||||
|
multiview: None,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
impl State {
|
||||||
|
async fn new(window: Window) -> anyhow::Result<Self> {
|
||||||
|
let size = window.inner_size();
|
||||||
|
|
||||||
|
// The instance is a handle to our GPU
|
||||||
|
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
|
||||||
|
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
|
||||||
|
// UPDATED
|
||||||
|
#[cfg(target_arch="wasm32")]
|
||||||
|
backends: wgpu::Backends::BROWSER_WEBGPU,
|
||||||
|
#[cfg(not(target_arch="wasm32"))]
|
||||||
|
backends: wgpu::Backends::all(),
|
||||||
|
..Default::default()
|
||||||
|
});
|
||||||
|
|
||||||
|
// # Safety
|
||||||
|
//
|
||||||
|
// The surface needs to live as long as the window that created it.
|
||||||
|
// State owns the window so this should be safe.
|
||||||
|
let surface = unsafe { instance.create_surface(&window) }.unwrap();
|
||||||
|
|
||||||
|
let adapter = instance
|
||||||
|
.request_adapter(&wgpu::RequestAdapterOptions {
|
||||||
|
power_preference: wgpu::PowerPreference::default(),
|
||||||
|
compatible_surface: Some(&surface),
|
||||||
|
force_fallback_adapter: false,
|
||||||
|
})
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
let (device, queue) = adapter
|
||||||
|
.request_device(
|
||||||
|
&wgpu::DeviceDescriptor {
|
||||||
|
label: None,
|
||||||
|
// UPDATED!
|
||||||
|
features: wgpu::Features::empty(),
|
||||||
|
// UPDATED!
|
||||||
|
limits: wgpu::Limits::downlevel_defaults(),
|
||||||
|
},
|
||||||
|
None, // Trace path
|
||||||
|
)
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let surface_caps = surface.get_capabilities(&adapter);
|
||||||
|
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
|
||||||
|
// one will result all the colors comming out darker. If you want to support non
|
||||||
|
// Srgb surfaces, you'll need to account for that when drawing to the frame.
|
||||||
|
let surface_format = surface_caps
|
||||||
|
.formats
|
||||||
|
.iter()
|
||||||
|
.copied()
|
||||||
|
.find(|f| f.is_srgb())
|
||||||
|
.unwrap_or(surface_caps.formats[0]);
|
||||||
|
let config = wgpu::SurfaceConfiguration {
|
||||||
|
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
|
||||||
|
format: surface_format,
|
||||||
|
width: size.width,
|
||||||
|
height: size.height,
|
||||||
|
present_mode: surface_caps.present_modes[0],
|
||||||
|
alpha_mode: surface_caps.alpha_modes[0],
|
||||||
|
view_formats: vec![],
|
||||||
|
};
|
||||||
|
|
||||||
|
surface.configure(&device, &config);
|
||||||
|
|
||||||
|
let texture_bind_group_layout =
|
||||||
|
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
||||||
|
entries: &[
|
||||||
|
wgpu::BindGroupLayoutEntry {
|
||||||
|
binding: 0,
|
||||||
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
||||||
|
ty: wgpu::BindingType::Texture {
|
||||||
|
multisampled: false,
|
||||||
|
sample_type: wgpu::TextureSampleType::Float { filterable: true },
|
||||||
|
view_dimension: wgpu::TextureViewDimension::D2,
|
||||||
|
},
|
||||||
|
count: None,
|
||||||
|
},
|
||||||
|
wgpu::BindGroupLayoutEntry {
|
||||||
|
binding: 1,
|
||||||
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
||||||
|
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
|
||||||
|
count: None,
|
||||||
|
},
|
||||||
|
// normal map
|
||||||
|
wgpu::BindGroupLayoutEntry {
|
||||||
|
binding: 2,
|
||||||
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
||||||
|
ty: wgpu::BindingType::Texture {
|
||||||
|
multisampled: false,
|
||||||
|
sample_type: wgpu::TextureSampleType::Float { filterable: true },
|
||||||
|
view_dimension: wgpu::TextureViewDimension::D2,
|
||||||
|
},
|
||||||
|
count: None,
|
||||||
|
},
|
||||||
|
wgpu::BindGroupLayoutEntry {
|
||||||
|
binding: 3,
|
||||||
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
||||||
|
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
|
||||||
|
count: None,
|
||||||
|
},
|
||||||
|
],
|
||||||
|
label: Some("texture_bind_group_layout"),
|
||||||
|
});
|
||||||
|
|
||||||
|
let camera = camera::Camera::new((0.0, 5.0, 10.0), cgmath::Deg(-90.0), cgmath::Deg(-20.0));
|
||||||
|
let projection =
|
||||||
|
camera::Projection::new(config.width, config.height, cgmath::Deg(45.0), 0.1, 100.0);
|
||||||
|
let camera_controller = camera::CameraController::new(4.0, 0.4);
|
||||||
|
|
||||||
|
let mut camera_uniform = CameraUniform::new();
|
||||||
|
camera_uniform.update_view_proj(&camera, &projection);
|
||||||
|
|
||||||
|
let camera_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
||||||
|
label: Some("Camera Buffer"),
|
||||||
|
contents: bytemuck::cast_slice(&[camera_uniform]),
|
||||||
|
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
|
||||||
|
});
|
||||||
|
|
||||||
|
const SPACE_BETWEEN: f32 = 3.0;
|
||||||
|
let instances = (0..NUM_INSTANCES_PER_ROW)
|
||||||
|
.flat_map(|z| {
|
||||||
|
(0..NUM_INSTANCES_PER_ROW).map(move |x| {
|
||||||
|
let x = SPACE_BETWEEN * (x as f32 - NUM_INSTANCES_PER_ROW as f32 / 2.0);
|
||||||
|
let z = SPACE_BETWEEN * (z as f32 - NUM_INSTANCES_PER_ROW as f32 / 2.0);
|
||||||
|
|
||||||
|
let position = cgmath::Vector3 { x, y: 0.0, z };
|
||||||
|
|
||||||
|
let rotation = if position.is_zero() {
|
||||||
|
cgmath::Quaternion::from_axis_angle(
|
||||||
|
cgmath::Vector3::unit_z(),
|
||||||
|
cgmath::Deg(0.0),
|
||||||
|
)
|
||||||
|
} else {
|
||||||
|
cgmath::Quaternion::from_axis_angle(position.normalize(), cgmath::Deg(45.0))
|
||||||
|
};
|
||||||
|
|
||||||
|
Instance { position, rotation }
|
||||||
|
})
|
||||||
|
})
|
||||||
|
.collect::<Vec<_>>();
|
||||||
|
|
||||||
|
let instance_data = instances.iter().map(Instance::to_raw).collect::<Vec<_>>();
|
||||||
|
let instance_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
||||||
|
label: Some("Instance Buffer"),
|
||||||
|
contents: bytemuck::cast_slice(&instance_data),
|
||||||
|
usage: wgpu::BufferUsages::VERTEX,
|
||||||
|
});
|
||||||
|
|
||||||
|
let camera_bind_group_layout =
|
||||||
|
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
||||||
|
entries: &[wgpu::BindGroupLayoutEntry {
|
||||||
|
binding: 0,
|
||||||
|
visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
|
||||||
|
ty: wgpu::BindingType::Buffer {
|
||||||
|
ty: wgpu::BufferBindingType::Uniform,
|
||||||
|
has_dynamic_offset: false,
|
||||||
|
min_binding_size: None,
|
||||||
|
},
|
||||||
|
count: None,
|
||||||
|
}],
|
||||||
|
label: Some("camera_bind_group_layout"),
|
||||||
|
});
|
||||||
|
|
||||||
|
let camera_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
|
||||||
|
layout: &camera_bind_group_layout,
|
||||||
|
entries: &[wgpu::BindGroupEntry {
|
||||||
|
binding: 0,
|
||||||
|
resource: camera_buffer.as_entire_binding(),
|
||||||
|
}],
|
||||||
|
label: Some("camera_bind_group"),
|
||||||
|
});
|
||||||
|
|
||||||
|
let obj_model =
|
||||||
|
resources::load_model("cube.obj", &device, &queue, &texture_bind_group_layout)
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let light_uniform = LightUniform {
|
||||||
|
position: [2.0, 2.0, 2.0],
|
||||||
|
_padding: 0,
|
||||||
|
color: [1.0, 1.0, 1.0],
|
||||||
|
_padding2: 0,
|
||||||
|
};
|
||||||
|
|
||||||
|
let light_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
||||||
|
label: Some("Light VB"),
|
||||||
|
contents: bytemuck::cast_slice(&[light_uniform]),
|
||||||
|
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
|
||||||
|
});
|
||||||
|
|
||||||
|
let light_bind_group_layout =
|
||||||
|
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
||||||
|
entries: &[wgpu::BindGroupLayoutEntry {
|
||||||
|
binding: 0,
|
||||||
|
visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
|
||||||
|
ty: wgpu::BindingType::Buffer {
|
||||||
|
ty: wgpu::BufferBindingType::Uniform,
|
||||||
|
has_dynamic_offset: false,
|
||||||
|
min_binding_size: None,
|
||||||
|
},
|
||||||
|
count: None,
|
||||||
|
}],
|
||||||
|
label: None,
|
||||||
|
});
|
||||||
|
|
||||||
|
let light_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
|
||||||
|
layout: &light_bind_group_layout,
|
||||||
|
entries: &[wgpu::BindGroupEntry {
|
||||||
|
binding: 0,
|
||||||
|
resource: light_buffer.as_entire_binding(),
|
||||||
|
}],
|
||||||
|
label: None,
|
||||||
|
});
|
||||||
|
|
||||||
|
let depth_texture =
|
||||||
|
texture::Texture::create_depth_texture(&device, &config, "depth_texture");
|
||||||
|
|
||||||
|
// NEW!
|
||||||
|
let hdr = hdr::HdrPipeline::new(&device, &config);
|
||||||
|
|
||||||
|
let hdr_loader = resources::HdrLoader::new(&device);
|
||||||
|
let sky_bytes = resources::load_binary("pure-sky.hdr").await?;
|
||||||
|
let sky_texture = hdr_loader.from_equirectangular_bytes(
|
||||||
|
&device,
|
||||||
|
&queue,
|
||||||
|
&sky_bytes,
|
||||||
|
1080,
|
||||||
|
Some("Sky Texture"),
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let environment_layout =
|
||||||
|
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
||||||
|
label: Some("environment_layout"),
|
||||||
|
entries: &[
|
||||||
|
wgpu::BindGroupLayoutEntry {
|
||||||
|
binding: 0,
|
||||||
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
||||||
|
ty: wgpu::BindingType::Texture {
|
||||||
|
sample_type: wgpu::TextureSampleType::Float { filterable: false },
|
||||||
|
view_dimension: wgpu::TextureViewDimension::Cube,
|
||||||
|
multisampled: false,
|
||||||
|
},
|
||||||
|
count: None,
|
||||||
|
},
|
||||||
|
wgpu::BindGroupLayoutEntry {
|
||||||
|
binding: 1,
|
||||||
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
||||||
|
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::NonFiltering),
|
||||||
|
count: None,
|
||||||
|
},
|
||||||
|
],
|
||||||
|
});
|
||||||
|
|
||||||
|
let environment_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
|
||||||
|
label: Some("environment_bind_group"),
|
||||||
|
layout: &environment_layout,
|
||||||
|
entries: &[
|
||||||
|
wgpu::BindGroupEntry {
|
||||||
|
binding: 0,
|
||||||
|
resource: wgpu::BindingResource::TextureView(&sky_texture.view()),
|
||||||
|
},
|
||||||
|
wgpu::BindGroupEntry {
|
||||||
|
binding: 1,
|
||||||
|
resource: wgpu::BindingResource::Sampler(sky_texture.sampler()),
|
||||||
|
},
|
||||||
|
],
|
||||||
|
});
|
||||||
|
|
||||||
|
let render_pipeline_layout =
|
||||||
|
device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
||||||
|
label: Some("Render Pipeline Layout"),
|
||||||
|
bind_group_layouts: &[
|
||||||
|
&texture_bind_group_layout,
|
||||||
|
&camera_bind_group_layout,
|
||||||
|
&light_bind_group_layout,
|
||||||
|
&environment_layout, // UPDATED!
|
||||||
|
],
|
||||||
|
push_constant_ranges: &[],
|
||||||
|
});
|
||||||
|
|
||||||
|
let render_pipeline = {
|
||||||
|
let shader = wgpu::ShaderModuleDescriptor {
|
||||||
|
label: Some("Normal Shader"),
|
||||||
|
source: wgpu::ShaderSource::Wgsl(include_str!("shader.wgsl").into()),
|
||||||
|
};
|
||||||
|
create_render_pipeline(
|
||||||
|
&device,
|
||||||
|
&render_pipeline_layout,
|
||||||
|
hdr.format(),
|
||||||
|
Some(texture::Texture::DEPTH_FORMAT),
|
||||||
|
&[model::ModelVertex::desc(), InstanceRaw::desc()],
|
||||||
|
wgpu::PrimitiveTopology::TriangleList,
|
||||||
|
shader,
|
||||||
|
)
|
||||||
|
};
|
||||||
|
|
||||||
|
let light_render_pipeline = {
|
||||||
|
let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
||||||
|
label: Some("Light Pipeline Layout"),
|
||||||
|
bind_group_layouts: &[&camera_bind_group_layout, &light_bind_group_layout],
|
||||||
|
push_constant_ranges: &[],
|
||||||
|
});
|
||||||
|
let shader = wgpu::ShaderModuleDescriptor {
|
||||||
|
label: Some("Light Shader"),
|
||||||
|
source: wgpu::ShaderSource::Wgsl(include_str!("light.wgsl").into()),
|
||||||
|
};
|
||||||
|
create_render_pipeline(
|
||||||
|
&device,
|
||||||
|
&layout,
|
||||||
|
hdr.format(),
|
||||||
|
Some(texture::Texture::DEPTH_FORMAT),
|
||||||
|
&[model::ModelVertex::desc()],
|
||||||
|
wgpu::PrimitiveTopology::TriangleList,
|
||||||
|
shader,
|
||||||
|
)
|
||||||
|
};
|
||||||
|
|
||||||
|
// NEW!
|
||||||
|
let sky_pipeline = {
|
||||||
|
let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
||||||
|
label: Some("Sky Pipeline Layout"),
|
||||||
|
bind_group_layouts: &[&camera_bind_group_layout, &environment_layout],
|
||||||
|
push_constant_ranges: &[],
|
||||||
|
});
|
||||||
|
let shader = wgpu::include_wgsl!("sky.wgsl");
|
||||||
|
create_render_pipeline(
|
||||||
|
&device,
|
||||||
|
&layout,
|
||||||
|
hdr.format(),
|
||||||
|
Some(texture::Texture::DEPTH_FORMAT),
|
||||||
|
&[],
|
||||||
|
wgpu::PrimitiveTopology::TriangleList,
|
||||||
|
shader,
|
||||||
|
)
|
||||||
|
};
|
||||||
|
|
||||||
|
let debug_material = {
|
||||||
|
let diffuse_bytes = include_bytes!("../res/cobble-diffuse.png");
|
||||||
|
let normal_bytes = include_bytes!("../res/cobble-normal.png");
|
||||||
|
|
||||||
|
let diffuse_texture = texture::Texture::from_bytes(
|
||||||
|
&device,
|
||||||
|
&queue,
|
||||||
|
diffuse_bytes,
|
||||||
|
"res/alt-diffuse.png",
|
||||||
|
false,
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
let normal_texture = texture::Texture::from_bytes(
|
||||||
|
&device,
|
||||||
|
&queue,
|
||||||
|
normal_bytes,
|
||||||
|
"res/alt-normal.png",
|
||||||
|
true,
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
model::Material::new(
|
||||||
|
&device,
|
||||||
|
"alt-material",
|
||||||
|
diffuse_texture,
|
||||||
|
normal_texture,
|
||||||
|
&texture_bind_group_layout,
|
||||||
|
)
|
||||||
|
};
|
||||||
|
|
||||||
|
#[cfg(feature = "debug")]
|
||||||
|
let debug = debug::Debug::new(&device, &camera_bind_group_layout, surface_format);
|
||||||
|
|
||||||
|
Ok(Self {
|
||||||
|
window,
|
||||||
|
surface,
|
||||||
|
device,
|
||||||
|
queue,
|
||||||
|
config,
|
||||||
|
render_pipeline,
|
||||||
|
obj_model,
|
||||||
|
camera,
|
||||||
|
projection,
|
||||||
|
camera_controller,
|
||||||
|
camera_buffer,
|
||||||
|
camera_bind_group,
|
||||||
|
camera_uniform,
|
||||||
|
instances,
|
||||||
|
instance_buffer,
|
||||||
|
depth_texture,
|
||||||
|
size,
|
||||||
|
light_uniform,
|
||||||
|
light_buffer,
|
||||||
|
light_bind_group,
|
||||||
|
light_render_pipeline,
|
||||||
|
#[allow(dead_code)]
|
||||||
|
debug_material,
|
||||||
|
mouse_pressed: false,
|
||||||
|
// NEW!
|
||||||
|
hdr,
|
||||||
|
environment_bind_group,
|
||||||
|
sky_pipeline,
|
||||||
|
|
||||||
|
#[cfg(feature = "debug")]
|
||||||
|
debug,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn window(&self) -> &Window {
|
||||||
|
&self.window
|
||||||
|
}
|
||||||
|
|
||||||
|
fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
|
||||||
|
// UPDATED!
|
||||||
|
if new_size.width > 0 && new_size.height > 0 {
|
||||||
|
self.projection.resize(new_size.width, new_size.height);
|
||||||
|
self.hdr
|
||||||
|
.resize(&self.device, new_size.width, new_size.height);
|
||||||
|
self.size = new_size;
|
||||||
|
self.config.width = new_size.width;
|
||||||
|
self.config.height = new_size.height;
|
||||||
|
self.surface.configure(&self.device, &self.config);
|
||||||
|
self.depth_texture =
|
||||||
|
texture::Texture::create_depth_texture(&self.device, &self.config, "depth_texture");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn input(&mut self, event: &WindowEvent) -> bool {
|
||||||
|
match event {
|
||||||
|
WindowEvent::KeyboardInput {
|
||||||
|
input:
|
||||||
|
KeyboardInput {
|
||||||
|
virtual_keycode: Some(key),
|
||||||
|
state,
|
||||||
|
..
|
||||||
|
},
|
||||||
|
..
|
||||||
|
} => self.camera_controller.process_keyboard(*key, *state),
|
||||||
|
WindowEvent::MouseWheel { delta, .. } => {
|
||||||
|
self.camera_controller.process_scroll(delta);
|
||||||
|
true
|
||||||
|
}
|
||||||
|
WindowEvent::MouseInput {
|
||||||
|
button: MouseButton::Left,
|
||||||
|
state,
|
||||||
|
..
|
||||||
|
} => {
|
||||||
|
self.mouse_pressed = *state == ElementState::Pressed;
|
||||||
|
true
|
||||||
|
}
|
||||||
|
_ => false,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn update(&mut self, dt: std::time::Duration) {
|
||||||
|
self.camera_controller.update_camera(&mut self.camera, dt);
|
||||||
|
self.camera_uniform
|
||||||
|
.update_view_proj(&self.camera, &self.projection);
|
||||||
|
self.queue.write_buffer(
|
||||||
|
&self.camera_buffer,
|
||||||
|
0,
|
||||||
|
bytemuck::cast_slice(&[self.camera_uniform]),
|
||||||
|
);
|
||||||
|
|
||||||
|
// Update the light
|
||||||
|
let old_position: cgmath::Vector3<_> = self.light_uniform.position.into();
|
||||||
|
self.light_uniform.position =
|
||||||
|
(cgmath::Quaternion::from_axis_angle((0.0, 1.0, 0.0).into(), cgmath::Deg(1.0))
|
||||||
|
* old_position)
|
||||||
|
.into();
|
||||||
|
self.queue.write_buffer(
|
||||||
|
&self.light_buffer,
|
||||||
|
0,
|
||||||
|
bytemuck::cast_slice(&[self.light_uniform]),
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn render(&mut self) -> Result<(), wgpu::SurfaceError> {
|
||||||
|
let output = self.surface.get_current_texture()?;
|
||||||
|
let view = output
|
||||||
|
.texture
|
||||||
|
.create_view(&wgpu::TextureViewDescriptor::default());
|
||||||
|
|
||||||
|
let mut encoder = self
|
||||||
|
.device
|
||||||
|
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
|
||||||
|
label: Some("Render Encoder"),
|
||||||
|
});
|
||||||
|
|
||||||
|
{
|
||||||
|
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
||||||
|
label: Some("Render Pass"),
|
||||||
|
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
|
||||||
|
view: self.hdr.view(), // UPDATED!
|
||||||
|
resolve_target: None,
|
||||||
|
ops: wgpu::Operations {
|
||||||
|
load: wgpu::LoadOp::Clear(wgpu::Color {
|
||||||
|
r: 0.1,
|
||||||
|
g: 0.2,
|
||||||
|
b: 0.3,
|
||||||
|
a: 1.0,
|
||||||
|
}),
|
||||||
|
store: wgpu::StoreOp::Store,
|
||||||
|
},
|
||||||
|
})],
|
||||||
|
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
|
||||||
|
view: &self.depth_texture.view,
|
||||||
|
depth_ops: Some(wgpu::Operations {
|
||||||
|
load: wgpu::LoadOp::Clear(1.0),
|
||||||
|
store: wgpu::StoreOp::Store,
|
||||||
|
}),
|
||||||
|
stencil_ops: None,
|
||||||
|
}),
|
||||||
|
occlusion_query_set: None,
|
||||||
|
timestamp_writes: None,
|
||||||
|
});
|
||||||
|
|
||||||
|
render_pass.set_vertex_buffer(1, self.instance_buffer.slice(..));
|
||||||
|
render_pass.set_pipeline(&self.light_render_pipeline);
|
||||||
|
render_pass.draw_light_model(
|
||||||
|
&self.obj_model,
|
||||||
|
&self.camera_bind_group,
|
||||||
|
&self.light_bind_group,
|
||||||
|
);
|
||||||
|
|
||||||
|
render_pass.set_pipeline(&self.render_pipeline);
|
||||||
|
render_pass.draw_model_instanced(
|
||||||
|
&self.obj_model,
|
||||||
|
0..self.instances.len() as u32,
|
||||||
|
&self.camera_bind_group,
|
||||||
|
&self.light_bind_group,
|
||||||
|
&self.environment_bind_group,
|
||||||
|
);
|
||||||
|
|
||||||
|
render_pass.set_pipeline(&self.sky_pipeline);
|
||||||
|
render_pass.set_bind_group(0, &self.camera_bind_group, &[]);
|
||||||
|
render_pass.set_bind_group(1, &self.environment_bind_group, &[]);
|
||||||
|
render_pass.draw(0..3, 0..1);
|
||||||
|
}
|
||||||
|
|
||||||
|
// NEW!
|
||||||
|
// Apply tonemapping
|
||||||
|
self.hdr.process(&mut encoder, &view);
|
||||||
|
|
||||||
|
#[cfg(feature = "debug")]
|
||||||
|
{
|
||||||
|
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
||||||
|
label: Some("Debug"),
|
||||||
|
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
|
||||||
|
view: &view,
|
||||||
|
resolve_target: None,
|
||||||
|
ops: wgpu::Operations {
|
||||||
|
load: wgpu::LoadOp::Load,
|
||||||
|
store: wgpu::StoreOp::Store,
|
||||||
|
},
|
||||||
|
})],
|
||||||
|
depth_stencil_attachment: None,
|
||||||
|
occlusion_query_set: None,
|
||||||
|
timestamp_writes: None,
|
||||||
|
});
|
||||||
|
self.debug.draw_axis(&mut pass, &self.camera_bind_group);
|
||||||
|
}
|
||||||
|
|
||||||
|
self.queue.submit(iter::once(encoder.finish()));
|
||||||
|
output.present();
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg_attr(target_arch = "wasm32", wasm_bindgen(start))]
|
||||||
|
pub async fn run() {
|
||||||
|
cfg_if::cfg_if! {
|
||||||
|
if #[cfg(target_arch = "wasm32")] {
|
||||||
|
std::panic::set_hook(Box::new(console_error_panic_hook::hook));
|
||||||
|
console_log::init_with_level(log::Level::Info).expect("Could't initialize logger");
|
||||||
|
} else {
|
||||||
|
env_logger::init();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
let event_loop = EventLoop::new();
|
||||||
|
let title = env!("CARGO_PKG_NAME");
|
||||||
|
let window = winit::window::WindowBuilder::new()
|
||||||
|
.with_title(title)
|
||||||
|
.build(&event_loop)
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
#[cfg(target_arch = "wasm32")]
|
||||||
|
{
|
||||||
|
// Winit prevents sizing with CSS, so we have to set
|
||||||
|
// the size manually when on web.
|
||||||
|
use winit::dpi::PhysicalSize;
|
||||||
|
window.set_inner_size(PhysicalSize::new(450, 400));
|
||||||
|
|
||||||
|
use winit::platform::web::WindowExtWebSys;
|
||||||
|
web_sys::window()
|
||||||
|
.and_then(|win| win.document())
|
||||||
|
.and_then(|doc| {
|
||||||
|
let dst = doc.get_element_by_id("wasm-example")?;
|
||||||
|
let canvas = web_sys::Element::from(window.canvas());
|
||||||
|
dst.append_child(&canvas).ok()?;
|
||||||
|
Some(())
|
||||||
|
})
|
||||||
|
.expect("Couldn't append canvas to document body.");
|
||||||
|
}
|
||||||
|
|
||||||
|
let mut state = State::new(window).await.unwrap(); // NEW!
|
||||||
|
let mut last_render_time = instant::Instant::now();
|
||||||
|
event_loop.run(move |event, _, control_flow| {
|
||||||
|
*control_flow = ControlFlow::Poll;
|
||||||
|
match event {
|
||||||
|
Event::MainEventsCleared => state.window().request_redraw(),
|
||||||
|
Event::DeviceEvent {
|
||||||
|
event: DeviceEvent::MouseMotion{ delta, },
|
||||||
|
.. // We're not using device_id currently
|
||||||
|
} => if state.mouse_pressed {
|
||||||
|
state.camera_controller.process_mouse(delta.0, delta.1)
|
||||||
|
}
|
||||||
|
// UPDATED!
|
||||||
|
Event::WindowEvent {
|
||||||
|
ref event,
|
||||||
|
window_id,
|
||||||
|
} if window_id == state.window().id() && !state.input(event) => {
|
||||||
|
match event {
|
||||||
|
#[cfg(not(target_arch="wasm32"))]
|
||||||
|
WindowEvent::CloseRequested
|
||||||
|
| WindowEvent::KeyboardInput {
|
||||||
|
input:
|
||||||
|
KeyboardInput {
|
||||||
|
state: ElementState::Pressed,
|
||||||
|
virtual_keycode: Some(VirtualKeyCode::Escape),
|
||||||
|
..
|
||||||
|
},
|
||||||
|
..
|
||||||
|
} => *control_flow = ControlFlow::Exit,
|
||||||
|
WindowEvent::Resized(physical_size) => {
|
||||||
|
state.resize(*physical_size);
|
||||||
|
}
|
||||||
|
WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
|
||||||
|
state.resize(**new_inner_size);
|
||||||
|
}
|
||||||
|
_ => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// UPDATED!
|
||||||
|
Event::RedrawRequested(window_id) if window_id == state.window().id() => {
|
||||||
|
let now = instant::Instant::now();
|
||||||
|
let dt = now - last_render_time;
|
||||||
|
last_render_time = now;
|
||||||
|
state.update(dt);
|
||||||
|
match state.render() {
|
||||||
|
Ok(_) => {}
|
||||||
|
// Reconfigure the surface if it's lost or outdated
|
||||||
|
Err(wgpu::SurfaceError::Lost | wgpu::SurfaceError::Outdated) => state.resize(state.size),
|
||||||
|
// The system is out of memory, we should probably quit
|
||||||
|
Err(wgpu::SurfaceError::OutOfMemory) => *control_flow = ControlFlow::Exit,
|
||||||
|
// We're ignoring timeouts
|
||||||
|
Err(wgpu::SurfaceError::Timeout) => log::warn!("Surface timeout"),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
_ => {}
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
@ -0,0 +1,45 @@
|
|||||||
|
// Vertex shader
|
||||||
|
|
||||||
|
struct Camera {
|
||||||
|
view_pos: vec4<f32>,
|
||||||
|
view: mat4x4<f32>,
|
||||||
|
view_proj: mat4x4<f32>,
|
||||||
|
inv_proj: mat4x4<f32>,
|
||||||
|
inv_view: mat4x4<f32>,
|
||||||
|
}
|
||||||
|
@group(0) @binding(0)
|
||||||
|
var<uniform> camera: Camera;
|
||||||
|
|
||||||
|
struct Light {
|
||||||
|
position: vec3<f32>,
|
||||||
|
color: vec3<f32>,
|
||||||
|
}
|
||||||
|
@group(1) @binding(0)
|
||||||
|
var<uniform> light: Light;
|
||||||
|
|
||||||
|
struct VertexInput {
|
||||||
|
@location(0) position: vec3<f32>,
|
||||||
|
};
|
||||||
|
|
||||||
|
struct VertexOutput {
|
||||||
|
@builtin(position) clip_position: vec4<f32>,
|
||||||
|
@location(0) color: vec3<f32>,
|
||||||
|
};
|
||||||
|
|
||||||
|
@vertex
|
||||||
|
fn vs_main(
|
||||||
|
model: VertexInput,
|
||||||
|
) -> VertexOutput {
|
||||||
|
let scale = 0.25;
|
||||||
|
var out: VertexOutput;
|
||||||
|
out.clip_position = camera.view_proj * vec4<f32>(model.position * scale + light.position, 1.0);
|
||||||
|
out.color = light.color;
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Fragment shader
|
||||||
|
|
||||||
|
@fragment
|
||||||
|
fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
|
||||||
|
return vec4<f32>(in.color, 1.0);
|
||||||
|
}
|
@ -0,0 +1,5 @@
|
|||||||
|
use tutorial13_hdr::run;
|
||||||
|
|
||||||
|
fn main() {
|
||||||
|
pollster::block_on(run());
|
||||||
|
}
|
@ -0,0 +1,342 @@
|
|||||||
|
use std::ops::Range;
|
||||||
|
|
||||||
|
use crate::texture;
|
||||||
|
|
||||||
|
pub trait Vertex {
|
||||||
|
fn desc() -> wgpu::VertexBufferLayout<'static>;
|
||||||
|
}
|
||||||
|
|
||||||
|
#[repr(C)]
|
||||||
|
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
|
||||||
|
pub struct ModelVertex {
|
||||||
|
pub position: [f32; 3],
|
||||||
|
pub tex_coords: [f32; 2],
|
||||||
|
pub normal: [f32; 3],
|
||||||
|
pub tangent: [f32; 3],
|
||||||
|
pub bitangent: [f32; 3],
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Vertex for ModelVertex {
|
||||||
|
fn desc() -> wgpu::VertexBufferLayout<'static> {
|
||||||
|
use std::mem;
|
||||||
|
wgpu::VertexBufferLayout {
|
||||||
|
array_stride: mem::size_of::<ModelVertex>() as wgpu::BufferAddress,
|
||||||
|
step_mode: wgpu::VertexStepMode::Vertex,
|
||||||
|
attributes: &[
|
||||||
|
wgpu::VertexAttribute {
|
||||||
|
offset: 0,
|
||||||
|
shader_location: 0,
|
||||||
|
format: wgpu::VertexFormat::Float32x3,
|
||||||
|
},
|
||||||
|
wgpu::VertexAttribute {
|
||||||
|
offset: mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
|
||||||
|
shader_location: 1,
|
||||||
|
format: wgpu::VertexFormat::Float32x2,
|
||||||
|
},
|
||||||
|
wgpu::VertexAttribute {
|
||||||
|
offset: mem::size_of::<[f32; 5]>() as wgpu::BufferAddress,
|
||||||
|
shader_location: 2,
|
||||||
|
format: wgpu::VertexFormat::Float32x3,
|
||||||
|
},
|
||||||
|
// Tangent and bitangent
|
||||||
|
wgpu::VertexAttribute {
|
||||||
|
offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress,
|
||||||
|
shader_location: 3,
|
||||||
|
format: wgpu::VertexFormat::Float32x3,
|
||||||
|
},
|
||||||
|
wgpu::VertexAttribute {
|
||||||
|
offset: mem::size_of::<[f32; 11]>() as wgpu::BufferAddress,
|
||||||
|
shader_location: 4,
|
||||||
|
format: wgpu::VertexFormat::Float32x3,
|
||||||
|
},
|
||||||
|
],
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub struct Material {
|
||||||
|
pub name: String,
|
||||||
|
pub diffuse_texture: texture::Texture,
|
||||||
|
pub normal_texture: texture::Texture,
|
||||||
|
pub bind_group: wgpu::BindGroup,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Material {
|
||||||
|
pub fn new(
|
||||||
|
device: &wgpu::Device,
|
||||||
|
name: &str,
|
||||||
|
diffuse_texture: texture::Texture,
|
||||||
|
normal_texture: texture::Texture,
|
||||||
|
layout: &wgpu::BindGroupLayout,
|
||||||
|
) -> Self {
|
||||||
|
let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
|
||||||
|
layout,
|
||||||
|
entries: &[
|
||||||
|
wgpu::BindGroupEntry {
|
||||||
|
binding: 0,
|
||||||
|
resource: wgpu::BindingResource::TextureView(&diffuse_texture.view),
|
||||||
|
},
|
||||||
|
wgpu::BindGroupEntry {
|
||||||
|
binding: 1,
|
||||||
|
resource: wgpu::BindingResource::Sampler(&diffuse_texture.sampler),
|
||||||
|
},
|
||||||
|
wgpu::BindGroupEntry {
|
||||||
|
binding: 2,
|
||||||
|
resource: wgpu::BindingResource::TextureView(&normal_texture.view),
|
||||||
|
},
|
||||||
|
wgpu::BindGroupEntry {
|
||||||
|
binding: 3,
|
||||||
|
resource: wgpu::BindingResource::Sampler(&normal_texture.sampler),
|
||||||
|
},
|
||||||
|
],
|
||||||
|
label: Some(name),
|
||||||
|
});
|
||||||
|
|
||||||
|
Self {
|
||||||
|
name: String::from(name),
|
||||||
|
diffuse_texture,
|
||||||
|
normal_texture,
|
||||||
|
bind_group,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub struct Mesh {
|
||||||
|
pub name: String,
|
||||||
|
pub vertex_buffer: wgpu::Buffer,
|
||||||
|
pub index_buffer: wgpu::Buffer,
|
||||||
|
pub num_elements: u32,
|
||||||
|
pub material: usize,
|
||||||
|
}
|
||||||
|
|
||||||
|
pub struct Model {
|
||||||
|
pub meshes: Vec<Mesh>,
|
||||||
|
pub materials: Vec<Material>,
|
||||||
|
}
|
||||||
|
|
||||||
|
pub trait DrawModel<'a> {
|
||||||
|
fn draw_mesh(
|
||||||
|
&mut self,
|
||||||
|
mesh: &'a Mesh,
|
||||||
|
material: &'a Material,
|
||||||
|
camera_bind_group: &'a wgpu::BindGroup,
|
||||||
|
light_bind_group: &'a wgpu::BindGroup,
|
||||||
|
environment_bind_group: &'a wgpu::BindGroup,
|
||||||
|
);
|
||||||
|
fn draw_mesh_instanced(
|
||||||
|
&mut self,
|
||||||
|
mesh: &'a Mesh,
|
||||||
|
material: &'a Material,
|
||||||
|
instances: Range<u32>,
|
||||||
|
camera_bind_group: &'a wgpu::BindGroup,
|
||||||
|
light_bind_group: &'a wgpu::BindGroup,
|
||||||
|
environment_bind_group: &'a wgpu::BindGroup,
|
||||||
|
);
|
||||||
|
|
||||||
|
fn draw_model(
|
||||||
|
&mut self,
|
||||||
|
model: &'a Model,
|
||||||
|
camera_bind_group: &'a wgpu::BindGroup,
|
||||||
|
light_bind_group: &'a wgpu::BindGroup,
|
||||||
|
environment_bind_group: &'a wgpu::BindGroup,
|
||||||
|
);
|
||||||
|
fn draw_model_instanced(
|
||||||
|
&mut self,
|
||||||
|
model: &'a Model,
|
||||||
|
instances: Range<u32>,
|
||||||
|
camera_bind_group: &'a wgpu::BindGroup,
|
||||||
|
light_bind_group: &'a wgpu::BindGroup,
|
||||||
|
environment_bind_group: &'a wgpu::BindGroup,
|
||||||
|
);
|
||||||
|
fn draw_model_instanced_with_material(
|
||||||
|
&mut self,
|
||||||
|
model: &'a Model,
|
||||||
|
material: &'a Material,
|
||||||
|
instances: Range<u32>,
|
||||||
|
camera_bind_group: &'a wgpu::BindGroup,
|
||||||
|
light_bind_group: &'a wgpu::BindGroup,
|
||||||
|
environment_bind_group: &'a wgpu::BindGroup,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a, 'b> DrawModel<'b> for wgpu::RenderPass<'a>
|
||||||
|
where
|
||||||
|
'b: 'a,
|
||||||
|
{
|
||||||
|
fn draw_mesh(
|
||||||
|
&mut self,
|
||||||
|
mesh: &'b Mesh,
|
||||||
|
material: &'b Material,
|
||||||
|
camera_bind_group: &'b wgpu::BindGroup,
|
||||||
|
light_bind_group: &'b wgpu::BindGroup,
|
||||||
|
environment_bind_group: &'b wgpu::BindGroup,
|
||||||
|
) {
|
||||||
|
self.draw_mesh_instanced(
|
||||||
|
mesh,
|
||||||
|
material,
|
||||||
|
0..1,
|
||||||
|
camera_bind_group,
|
||||||
|
light_bind_group,
|
||||||
|
environment_bind_group,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn draw_mesh_instanced(
|
||||||
|
&mut self,
|
||||||
|
mesh: &'b Mesh,
|
||||||
|
material: &'b Material,
|
||||||
|
instances: Range<u32>,
|
||||||
|
camera_bind_group: &'b wgpu::BindGroup,
|
||||||
|
light_bind_group: &'b wgpu::BindGroup,
|
||||||
|
environment_bind_group: &'b wgpu::BindGroup,
|
||||||
|
) {
|
||||||
|
self.set_vertex_buffer(0, mesh.vertex_buffer.slice(..));
|
||||||
|
self.set_index_buffer(mesh.index_buffer.slice(..), wgpu::IndexFormat::Uint32);
|
||||||
|
self.set_bind_group(0, &material.bind_group, &[]);
|
||||||
|
self.set_bind_group(1, camera_bind_group, &[]);
|
||||||
|
self.set_bind_group(2, light_bind_group, &[]);
|
||||||
|
self.set_bind_group(3, environment_bind_group, &[]);
|
||||||
|
self.draw_indexed(0..mesh.num_elements, 0, instances);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn draw_model(
|
||||||
|
&mut self,
|
||||||
|
model: &'b Model,
|
||||||
|
camera_bind_group: &'b wgpu::BindGroup,
|
||||||
|
light_bind_group: &'b wgpu::BindGroup,
|
||||||
|
environment_bind_group: &'b wgpu::BindGroup,
|
||||||
|
) {
|
||||||
|
self.draw_model_instanced(
|
||||||
|
model,
|
||||||
|
0..1,
|
||||||
|
camera_bind_group,
|
||||||
|
light_bind_group,
|
||||||
|
environment_bind_group,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn draw_model_instanced(
|
||||||
|
&mut self,
|
||||||
|
model: &'b Model,
|
||||||
|
instances: Range<u32>,
|
||||||
|
camera_bind_group: &'b wgpu::BindGroup,
|
||||||
|
light_bind_group: &'b wgpu::BindGroup,
|
||||||
|
environment_bind_group: &'b wgpu::BindGroup, // NEW!
|
||||||
|
) {
|
||||||
|
for mesh in &model.meshes {
|
||||||
|
let material = &model.materials[mesh.material];
|
||||||
|
self.draw_mesh_instanced(
|
||||||
|
mesh,
|
||||||
|
material,
|
||||||
|
instances.clone(),
|
||||||
|
camera_bind_group,
|
||||||
|
light_bind_group,
|
||||||
|
environment_bind_group,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn draw_model_instanced_with_material(
|
||||||
|
&mut self,
|
||||||
|
model: &'b Model,
|
||||||
|
material: &'b Material,
|
||||||
|
instances: Range<u32>,
|
||||||
|
camera_bind_group: &'b wgpu::BindGroup,
|
||||||
|
light_bind_group: &'b wgpu::BindGroup,
|
||||||
|
environment_bind_group: &'b wgpu::BindGroup,
|
||||||
|
) {
|
||||||
|
for mesh in &model.meshes {
|
||||||
|
self.draw_mesh_instanced(
|
||||||
|
mesh,
|
||||||
|
material,
|
||||||
|
instances.clone(),
|
||||||
|
camera_bind_group,
|
||||||
|
light_bind_group,
|
||||||
|
environment_bind_group,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub trait DrawLight<'a> {
|
||||||
|
fn draw_light_mesh(
|
||||||
|
&mut self,
|
||||||
|
mesh: &'a Mesh,
|
||||||
|
camera_bind_group: &'a wgpu::BindGroup,
|
||||||
|
light_bind_group: &'a wgpu::BindGroup,
|
||||||
|
);
|
||||||
|
fn draw_light_mesh_instanced(
|
||||||
|
&mut self,
|
||||||
|
mesh: &'a Mesh,
|
||||||
|
instances: Range<u32>,
|
||||||
|
camera_bind_group: &'a wgpu::BindGroup,
|
||||||
|
light_bind_group: &'a wgpu::BindGroup,
|
||||||
|
);
|
||||||
|
|
||||||
|
fn draw_light_model(
|
||||||
|
&mut self,
|
||||||
|
model: &'a Model,
|
||||||
|
camera_bind_group: &'a wgpu::BindGroup,
|
||||||
|
light_bind_group: &'a wgpu::BindGroup,
|
||||||
|
);
|
||||||
|
fn draw_light_model_instanced(
|
||||||
|
&mut self,
|
||||||
|
model: &'a Model,
|
||||||
|
instances: Range<u32>,
|
||||||
|
camera_bind_group: &'a wgpu::BindGroup,
|
||||||
|
light_bind_group: &'a wgpu::BindGroup,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a, 'b> DrawLight<'b> for wgpu::RenderPass<'a>
|
||||||
|
where
|
||||||
|
'b: 'a,
|
||||||
|
{
|
||||||
|
fn draw_light_mesh(
|
||||||
|
&mut self,
|
||||||
|
mesh: &'b Mesh,
|
||||||
|
camera_bind_group: &'b wgpu::BindGroup,
|
||||||
|
light_bind_group: &'b wgpu::BindGroup,
|
||||||
|
) {
|
||||||
|
self.draw_light_mesh_instanced(mesh, 0..1, camera_bind_group, light_bind_group);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn draw_light_mesh_instanced(
|
||||||
|
&mut self,
|
||||||
|
mesh: &'b Mesh,
|
||||||
|
instances: Range<u32>,
|
||||||
|
camera_bind_group: &'b wgpu::BindGroup,
|
||||||
|
light_bind_group: &'b wgpu::BindGroup,
|
||||||
|
) {
|
||||||
|
self.set_vertex_buffer(0, mesh.vertex_buffer.slice(..));
|
||||||
|
self.set_index_buffer(mesh.index_buffer.slice(..), wgpu::IndexFormat::Uint32);
|
||||||
|
self.set_bind_group(0, camera_bind_group, &[]);
|
||||||
|
self.set_bind_group(1, light_bind_group, &[]);
|
||||||
|
self.draw_indexed(0..mesh.num_elements, 0, instances);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn draw_light_model(
|
||||||
|
&mut self,
|
||||||
|
model: &'b Model,
|
||||||
|
camera_bind_group: &'b wgpu::BindGroup,
|
||||||
|
light_bind_group: &'b wgpu::BindGroup,
|
||||||
|
) {
|
||||||
|
self.draw_light_model_instanced(model, 0..1, camera_bind_group, light_bind_group);
|
||||||
|
}
|
||||||
|
fn draw_light_model_instanced(
|
||||||
|
&mut self,
|
||||||
|
model: &'b Model,
|
||||||
|
instances: Range<u32>,
|
||||||
|
camera_bind_group: &'b wgpu::BindGroup,
|
||||||
|
light_bind_group: &'b wgpu::BindGroup,
|
||||||
|
) {
|
||||||
|
for mesh in &model.meshes {
|
||||||
|
self.draw_light_mesh_instanced(
|
||||||
|
mesh,
|
||||||
|
instances.clone(),
|
||||||
|
camera_bind_group,
|
||||||
|
light_bind_group,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
@ -0,0 +1,372 @@
|
|||||||
|
use std::io::{BufReader, Cursor};
|
||||||
|
|
||||||
|
use cfg_if::cfg_if;
|
||||||
|
use image::codecs::hdr::HdrDecoder;
|
||||||
|
use wgpu::util::DeviceExt;
|
||||||
|
|
||||||
|
use crate::{model, texture};
|
||||||
|
|
||||||
|
#[cfg(target_arch = "wasm32")]
|
||||||
|
fn format_url(file_name: &str) -> reqwest::Url {
|
||||||
|
let window = web_sys::window().unwrap();
|
||||||
|
let location = window.location();
|
||||||
|
let mut origin = location.origin().unwrap();
|
||||||
|
if !origin.ends_with("learn-wgpu") {
|
||||||
|
origin = format!("{}/learn-wgpu", origin);
|
||||||
|
}
|
||||||
|
let base = reqwest::Url::parse(&format!("{}/", origin,)).unwrap();
|
||||||
|
base.join(file_name).unwrap()
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn load_string(file_name: &str) -> anyhow::Result<String> {
|
||||||
|
cfg_if! {
|
||||||
|
if #[cfg(target_arch = "wasm32")] {
|
||||||
|
let url = format_url(file_name);
|
||||||
|
let txt = reqwest::get(url)
|
||||||
|
.await?
|
||||||
|
.text()
|
||||||
|
.await?;
|
||||||
|
} else {
|
||||||
|
let path = std::path::Path::new(env!("OUT_DIR"))
|
||||||
|
.join("res")
|
||||||
|
.join(file_name);
|
||||||
|
let txt = std::fs::read_to_string(path)?;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(txt)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn load_binary(file_name: &str) -> anyhow::Result<Vec<u8>> {
|
||||||
|
cfg_if! {
|
||||||
|
if #[cfg(target_arch = "wasm32")] {
|
||||||
|
let url = format_url(file_name);
|
||||||
|
let data = reqwest::get(url)
|
||||||
|
.await?
|
||||||
|
.bytes()
|
||||||
|
.await?
|
||||||
|
.to_vec();
|
||||||
|
} else {
|
||||||
|
let path = std::path::Path::new(env!("OUT_DIR"))
|
||||||
|
.join("res")
|
||||||
|
.join(file_name);
|
||||||
|
let data = std::fs::read(path)?;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(data)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn load_texture(
|
||||||
|
file_name: &str,
|
||||||
|
is_normal_map: bool,
|
||||||
|
device: &wgpu::Device,
|
||||||
|
queue: &wgpu::Queue,
|
||||||
|
) -> anyhow::Result<texture::Texture> {
|
||||||
|
let data = load_binary(file_name).await?;
|
||||||
|
texture::Texture::from_bytes(device, queue, &data, file_name, is_normal_map)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn load_model(
|
||||||
|
file_name: &str,
|
||||||
|
device: &wgpu::Device,
|
||||||
|
queue: &wgpu::Queue,
|
||||||
|
layout: &wgpu::BindGroupLayout,
|
||||||
|
) -> anyhow::Result<model::Model> {
|
||||||
|
let obj_text = load_string(file_name).await?;
|
||||||
|
let obj_cursor = Cursor::new(obj_text);
|
||||||
|
let mut obj_reader = BufReader::new(obj_cursor);
|
||||||
|
|
||||||
|
let (models, obj_materials) = tobj::load_obj_buf_async(
|
||||||
|
&mut obj_reader,
|
||||||
|
&tobj::LoadOptions {
|
||||||
|
triangulate: true,
|
||||||
|
single_index: true,
|
||||||
|
..Default::default()
|
||||||
|
},
|
||||||
|
|p| async move {
|
||||||
|
let mat_text = load_string(&p).await.unwrap();
|
||||||
|
tobj::load_mtl_buf(&mut BufReader::new(Cursor::new(mat_text)))
|
||||||
|
},
|
||||||
|
)
|
||||||
|
.await?;
|
||||||
|
|
||||||
|
let mut materials = Vec::new();
|
||||||
|
for m in obj_materials? {
|
||||||
|
let diffuse_texture = load_texture(&m.diffuse_texture, false, device, queue).await?;
|
||||||
|
let normal_texture = load_texture(&m.normal_texture, true, device, queue).await?;
|
||||||
|
|
||||||
|
materials.push(model::Material::new(
|
||||||
|
device,
|
||||||
|
&m.name,
|
||||||
|
diffuse_texture,
|
||||||
|
normal_texture,
|
||||||
|
layout,
|
||||||
|
));
|
||||||
|
}
|
||||||
|
|
||||||
|
let meshes = models
|
||||||
|
.into_iter()
|
||||||
|
.map(|m| {
|
||||||
|
let mut vertices = (0..m.mesh.positions.len() / 3)
|
||||||
|
.map(|i| model::ModelVertex {
|
||||||
|
position: [
|
||||||
|
m.mesh.positions[i * 3],
|
||||||
|
m.mesh.positions[i * 3 + 1],
|
||||||
|
m.mesh.positions[i * 3 + 2],
|
||||||
|
],
|
||||||
|
tex_coords: [m.mesh.texcoords[i * 2], m.mesh.texcoords[i * 2 + 1]],
|
||||||
|
normal: [
|
||||||
|
m.mesh.normals[i * 3],
|
||||||
|
m.mesh.normals[i * 3 + 1],
|
||||||
|
m.mesh.normals[i * 3 + 2],
|
||||||
|
],
|
||||||
|
// We'll calculate these later
|
||||||
|
tangent: [0.0; 3],
|
||||||
|
bitangent: [0.0; 3],
|
||||||
|
})
|
||||||
|
.collect::<Vec<_>>();
|
||||||
|
|
||||||
|
let indices = &m.mesh.indices;
|
||||||
|
let mut triangles_included = vec![0; vertices.len()];
|
||||||
|
|
||||||
|
// Calculate tangents and bitangets. We're going to
|
||||||
|
// use the triangles, so we need to loop through the
|
||||||
|
// indices in chunks of 3
|
||||||
|
for c in indices.chunks(3) {
|
||||||
|
let v0 = vertices[c[0] as usize];
|
||||||
|
let v1 = vertices[c[1] as usize];
|
||||||
|
let v2 = vertices[c[2] as usize];
|
||||||
|
|
||||||
|
let pos0: cgmath::Vector3<_> = v0.position.into();
|
||||||
|
let pos1: cgmath::Vector3<_> = v1.position.into();
|
||||||
|
let pos2: cgmath::Vector3<_> = v2.position.into();
|
||||||
|
|
||||||
|
let uv0: cgmath::Vector2<_> = v0.tex_coords.into();
|
||||||
|
let uv1: cgmath::Vector2<_> = v1.tex_coords.into();
|
||||||
|
let uv2: cgmath::Vector2<_> = v2.tex_coords.into();
|
||||||
|
|
||||||
|
// Calculate the edges of the triangle
|
||||||
|
let delta_pos1 = pos1 - pos0;
|
||||||
|
let delta_pos2 = pos2 - pos0;
|
||||||
|
|
||||||
|
// This will give us a direction to calculate the
|
||||||
|
// tangent and bitangent
|
||||||
|
let delta_uv1 = uv1 - uv0;
|
||||||
|
let delta_uv2 = uv2 - uv0;
|
||||||
|
|
||||||
|
// Solving the following system of equations will
|
||||||
|
// give us the tangent and bitangent.
|
||||||
|
// delta_pos1 = delta_uv1.x * T + delta_u.y * B
|
||||||
|
// delta_pos2 = delta_uv2.x * T + delta_uv2.y * B
|
||||||
|
// Luckily, the place I found this equation provided
|
||||||
|
// the solution!
|
||||||
|
let r = 1.0 / (delta_uv1.x * delta_uv2.y - delta_uv1.y * delta_uv2.x);
|
||||||
|
let tangent = (delta_pos1 * delta_uv2.y - delta_pos2 * delta_uv1.y) * r;
|
||||||
|
// We flip the bitangent to enable right-handed normal
|
||||||
|
// maps with wgpu texture coordinate system
|
||||||
|
let bitangent = (delta_pos2 * delta_uv1.x - delta_pos1 * delta_uv2.x) * -r;
|
||||||
|
|
||||||
|
// We'll use the same tangent/bitangent for each vertex in the triangle
|
||||||
|
vertices[c[0] as usize].tangent =
|
||||||
|
(tangent + cgmath::Vector3::from(vertices[c[0] as usize].tangent)).into();
|
||||||
|
vertices[c[1] as usize].tangent =
|
||||||
|
(tangent + cgmath::Vector3::from(vertices[c[1] as usize].tangent)).into();
|
||||||
|
vertices[c[2] as usize].tangent =
|
||||||
|
(tangent + cgmath::Vector3::from(vertices[c[2] as usize].tangent)).into();
|
||||||
|
vertices[c[0] as usize].bitangent =
|
||||||
|
(bitangent + cgmath::Vector3::from(vertices[c[0] as usize].bitangent)).into();
|
||||||
|
vertices[c[1] as usize].bitangent =
|
||||||
|
(bitangent + cgmath::Vector3::from(vertices[c[1] as usize].bitangent)).into();
|
||||||
|
vertices[c[2] as usize].bitangent =
|
||||||
|
(bitangent + cgmath::Vector3::from(vertices[c[2] as usize].bitangent)).into();
|
||||||
|
|
||||||
|
// Used to average the tangents/bitangents
|
||||||
|
triangles_included[c[0] as usize] += 1;
|
||||||
|
triangles_included[c[1] as usize] += 1;
|
||||||
|
triangles_included[c[2] as usize] += 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Average the tangents/bitangents
|
||||||
|
for (i, n) in triangles_included.into_iter().enumerate() {
|
||||||
|
let denom = 1.0 / n as f32;
|
||||||
|
let mut v = &mut vertices[i];
|
||||||
|
v.tangent = (cgmath::Vector3::from(v.tangent) * denom).into();
|
||||||
|
v.bitangent = (cgmath::Vector3::from(v.bitangent) * denom).into();
|
||||||
|
}
|
||||||
|
|
||||||
|
let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
||||||
|
label: Some(&format!("{:?} Vertex Buffer", file_name)),
|
||||||
|
contents: bytemuck::cast_slice(&vertices),
|
||||||
|
usage: wgpu::BufferUsages::VERTEX,
|
||||||
|
});
|
||||||
|
let index_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
||||||
|
label: Some(&format!("{:?} Index Buffer", file_name)),
|
||||||
|
contents: bytemuck::cast_slice(&m.mesh.indices),
|
||||||
|
usage: wgpu::BufferUsages::INDEX,
|
||||||
|
});
|
||||||
|
|
||||||
|
model::Mesh {
|
||||||
|
name: file_name.to_string(),
|
||||||
|
vertex_buffer,
|
||||||
|
index_buffer,
|
||||||
|
num_elements: m.mesh.indices.len() as u32,
|
||||||
|
material: m.mesh.material_id.unwrap_or(0),
|
||||||
|
}
|
||||||
|
})
|
||||||
|
.collect::<Vec<_>>();
|
||||||
|
|
||||||
|
Ok(model::Model { meshes, materials })
|
||||||
|
}
|
||||||
|
|
||||||
|
pub struct HdrLoader {
|
||||||
|
texture_format: wgpu::TextureFormat,
|
||||||
|
equirect_layout: wgpu::BindGroupLayout,
|
||||||
|
equirect_to_cubemap: wgpu::ComputePipeline,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl HdrLoader {
|
||||||
|
pub fn new(device: &wgpu::Device) -> Self {
|
||||||
|
let module = device.create_shader_module(wgpu::include_wgsl!("equirectangular.wgsl"));
|
||||||
|
let texture_format = wgpu::TextureFormat::Rgba32Float;
|
||||||
|
let equirect_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
||||||
|
label: Some("HdrLoader::equirect_layout"),
|
||||||
|
entries: &[
|
||||||
|
wgpu::BindGroupLayoutEntry {
|
||||||
|
binding: 0,
|
||||||
|
visibility: wgpu::ShaderStages::COMPUTE,
|
||||||
|
ty: wgpu::BindingType::Texture {
|
||||||
|
sample_type: wgpu::TextureSampleType::Float { filterable: false },
|
||||||
|
view_dimension: wgpu::TextureViewDimension::D2,
|
||||||
|
multisampled: false,
|
||||||
|
},
|
||||||
|
count: None,
|
||||||
|
},
|
||||||
|
wgpu::BindGroupLayoutEntry {
|
||||||
|
binding: 1,
|
||||||
|
visibility: wgpu::ShaderStages::COMPUTE,
|
||||||
|
ty: wgpu::BindingType::StorageTexture {
|
||||||
|
access: wgpu::StorageTextureAccess::WriteOnly,
|
||||||
|
format: texture_format,
|
||||||
|
view_dimension: wgpu::TextureViewDimension::D2Array,
|
||||||
|
},
|
||||||
|
count: None,
|
||||||
|
},
|
||||||
|
],
|
||||||
|
});
|
||||||
|
|
||||||
|
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
||||||
|
label: None,
|
||||||
|
bind_group_layouts: &[&equirect_layout],
|
||||||
|
push_constant_ranges: &[],
|
||||||
|
});
|
||||||
|
|
||||||
|
let equirect_to_cubemap =
|
||||||
|
device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
||||||
|
label: Some("equirect_to_cubemap"),
|
||||||
|
layout: Some(&pipeline_layout),
|
||||||
|
module: &module,
|
||||||
|
entry_point: "compute_equirect_to_cubemap",
|
||||||
|
});
|
||||||
|
|
||||||
|
Self {
|
||||||
|
equirect_to_cubemap,
|
||||||
|
texture_format,
|
||||||
|
equirect_layout,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn from_equirectangular_bytes(
|
||||||
|
&self,
|
||||||
|
device: &wgpu::Device,
|
||||||
|
queue: &wgpu::Queue,
|
||||||
|
data: &[u8],
|
||||||
|
dst_size: u32,
|
||||||
|
label: Option<&str>,
|
||||||
|
) -> anyhow::Result<texture::CubeTexture> {
|
||||||
|
let hdr_decoder = HdrDecoder::new(Cursor::new(data))?;
|
||||||
|
let meta = hdr_decoder.metadata();
|
||||||
|
let mut pixels = vec![[0.0, 0.0, 0.0, 0.0]; meta.width as usize * meta.height as usize];
|
||||||
|
hdr_decoder.read_image_transform(
|
||||||
|
|pix| {
|
||||||
|
let rgb = pix.to_hdr();
|
||||||
|
[rgb.0[0], rgb.0[1], rgb.0[2], 1.0f32]
|
||||||
|
},
|
||||||
|
&mut pixels[..],
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let src = texture::Texture::create_2d_texture(
|
||||||
|
device,
|
||||||
|
meta.width,
|
||||||
|
meta.height,
|
||||||
|
self.texture_format,
|
||||||
|
wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
|
||||||
|
wgpu::FilterMode::Linear,
|
||||||
|
None,
|
||||||
|
);
|
||||||
|
|
||||||
|
queue.write_texture(
|
||||||
|
wgpu::ImageCopyTexture {
|
||||||
|
texture: &src.texture,
|
||||||
|
mip_level: 0,
|
||||||
|
origin: wgpu::Origin3d::ZERO,
|
||||||
|
aspect: wgpu::TextureAspect::All,
|
||||||
|
},
|
||||||
|
&bytemuck::cast_slice(&pixels),
|
||||||
|
wgpu::ImageDataLayout {
|
||||||
|
offset: 0,
|
||||||
|
bytes_per_row: Some(src.size.width * std::mem::size_of::<[f32; 4]>() as u32),
|
||||||
|
rows_per_image: Some(src.size.height),
|
||||||
|
},
|
||||||
|
src.size,
|
||||||
|
);
|
||||||
|
|
||||||
|
let dst = texture::CubeTexture::create_2d(
|
||||||
|
device,
|
||||||
|
dst_size,
|
||||||
|
dst_size,
|
||||||
|
self.texture_format,
|
||||||
|
1,
|
||||||
|
wgpu::TextureUsages::STORAGE_BINDING
|
||||||
|
| wgpu::TextureUsages::TEXTURE_BINDING,
|
||||||
|
wgpu::FilterMode::Nearest,
|
||||||
|
label,
|
||||||
|
);
|
||||||
|
|
||||||
|
let dst_view = dst.texture().create_view(&wgpu::TextureViewDescriptor {
|
||||||
|
label,
|
||||||
|
dimension: Some(wgpu::TextureViewDimension::D2Array),
|
||||||
|
// array_layer_count: Some(6),
|
||||||
|
..Default::default()
|
||||||
|
});
|
||||||
|
|
||||||
|
let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
|
||||||
|
label,
|
||||||
|
layout: &self.equirect_layout,
|
||||||
|
entries: &[
|
||||||
|
wgpu::BindGroupEntry {
|
||||||
|
binding: 0,
|
||||||
|
resource: wgpu::BindingResource::TextureView(&src.view),
|
||||||
|
},
|
||||||
|
wgpu::BindGroupEntry {
|
||||||
|
binding: 1,
|
||||||
|
resource: wgpu::BindingResource::TextureView(&dst_view),
|
||||||
|
},
|
||||||
|
],
|
||||||
|
});
|
||||||
|
|
||||||
|
let mut encoder = device.create_command_encoder(&Default::default());
|
||||||
|
let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { label, timestamp_writes: None });
|
||||||
|
|
||||||
|
let num_workgroups = (dst_size + 15) / 16;
|
||||||
|
pass.set_pipeline(&self.equirect_to_cubemap);
|
||||||
|
pass.set_bind_group(0, &bind_group, &[]);
|
||||||
|
pass.dispatch_workgroups(num_workgroups, num_workgroups, 6);
|
||||||
|
|
||||||
|
drop(pass);
|
||||||
|
|
||||||
|
queue.submit([encoder.finish()]);
|
||||||
|
|
||||||
|
Ok(dst)
|
||||||
|
}
|
||||||
|
}
|
@ -0,0 +1,139 @@
|
|||||||
|
// Vertex shader
|
||||||
|
|
||||||
|
struct Camera {
|
||||||
|
view_pos: vec4<f32>,
|
||||||
|
view: mat4x4<f32>,
|
||||||
|
view_proj: mat4x4<f32>,
|
||||||
|
inv_proj: mat4x4<f32>,
|
||||||
|
inv_view: mat4x4<f32>,
|
||||||
|
}
|
||||||
|
@group(1) @binding(0)
|
||||||
|
var<uniform> camera: Camera;
|
||||||
|
|
||||||
|
struct Light {
|
||||||
|
position: vec3<f32>,
|
||||||
|
color: vec3<f32>,
|
||||||
|
}
|
||||||
|
@group(2) @binding(0)
|
||||||
|
var<uniform> light: Light;
|
||||||
|
|
||||||
|
struct VertexInput {
|
||||||
|
@location(0) position: vec3<f32>,
|
||||||
|
@location(1) tex_coords: vec2<f32>,
|
||||||
|
@location(2) normal: vec3<f32>,
|
||||||
|
@location(3) tangent: vec3<f32>,
|
||||||
|
@location(4) bitangent: vec3<f32>,
|
||||||
|
}
|
||||||
|
struct InstanceInput {
|
||||||
|
@location(5) model_matrix_0: vec4<f32>,
|
||||||
|
@location(6) model_matrix_1: vec4<f32>,
|
||||||
|
@location(7) model_matrix_2: vec4<f32>,
|
||||||
|
@location(8) model_matrix_3: vec4<f32>,
|
||||||
|
@location(9) normal_matrix_0: vec3<f32>,
|
||||||
|
@location(10) normal_matrix_1: vec3<f32>,
|
||||||
|
@location(11) normal_matrix_2: vec3<f32>,
|
||||||
|
}
|
||||||
|
|
||||||
|
struct VertexOutput {
|
||||||
|
@builtin(position) clip_position: vec4<f32>,
|
||||||
|
@location(0) tex_coords: vec2<f32>,
|
||||||
|
// Updated!
|
||||||
|
@location(1) world_position: vec3<f32>,
|
||||||
|
@location(2) world_view_position: vec3<f32>,
|
||||||
|
@location(3) world_light_position: vec3<f32>,
|
||||||
|
@location(4) world_normal: vec3<f32>,
|
||||||
|
@location(5) world_tangent: vec3<f32>,
|
||||||
|
@location(6) world_bitangent: vec3<f32>,
|
||||||
|
}
|
||||||
|
|
||||||
|
@vertex
|
||||||
|
fn vs_main(
|
||||||
|
model: VertexInput,
|
||||||
|
instance: InstanceInput,
|
||||||
|
) -> VertexOutput {
|
||||||
|
let model_matrix = mat4x4<f32>(
|
||||||
|
instance.model_matrix_0,
|
||||||
|
instance.model_matrix_1,
|
||||||
|
instance.model_matrix_2,
|
||||||
|
instance.model_matrix_3,
|
||||||
|
);
|
||||||
|
let normal_matrix = mat3x3<f32>(
|
||||||
|
instance.normal_matrix_0,
|
||||||
|
instance.normal_matrix_1,
|
||||||
|
instance.normal_matrix_2,
|
||||||
|
);
|
||||||
|
|
||||||
|
// UPDATED!
|
||||||
|
let world_position = model_matrix * vec4<f32>(model.position, 1.0);
|
||||||
|
|
||||||
|
var out: VertexOutput;
|
||||||
|
out.clip_position = camera.view_proj * world_position;
|
||||||
|
out.tex_coords = model.tex_coords;
|
||||||
|
out.world_normal = normalize(normal_matrix * model.normal);
|
||||||
|
out.world_tangent = normalize(normal_matrix * model.tangent);
|
||||||
|
out.world_bitangent = normalize(normal_matrix * model.bitangent);
|
||||||
|
out.world_position = world_position.xyz;
|
||||||
|
out.world_view_position = camera.view_pos.xyz;
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Fragment shader
|
||||||
|
|
||||||
|
@group(0) @binding(0)
|
||||||
|
var t_diffuse: texture_2d<f32>;
|
||||||
|
@group(0)@binding(1)
|
||||||
|
var s_diffuse: sampler;
|
||||||
|
@group(0)@binding(2)
|
||||||
|
var t_normal: texture_2d<f32>;
|
||||||
|
@group(0) @binding(3)
|
||||||
|
var s_normal: sampler;
|
||||||
|
|
||||||
|
@group(3)
|
||||||
|
@binding(0)
|
||||||
|
var env_map: texture_cube<f32>;
|
||||||
|
@group(3)
|
||||||
|
@binding(1)
|
||||||
|
var env_sampler: sampler;
|
||||||
|
|
||||||
|
@fragment
|
||||||
|
fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
|
||||||
|
let object_color: vec4<f32> = textureSample(t_diffuse, s_diffuse, in.tex_coords);
|
||||||
|
let object_normal: vec4<f32> = textureSample(t_normal, s_normal, in.tex_coords);
|
||||||
|
|
||||||
|
// NEW!
|
||||||
|
// Adjust the tangent and bitangent using the Gramm-Schmidt process
|
||||||
|
// This makes sure that they are perpedicular to each other and the
|
||||||
|
// normal of the surface.
|
||||||
|
let world_tangent = normalize(in.world_tangent - dot(in.world_tangent, in.world_normal) * in.world_normal);
|
||||||
|
let world_bitangent = cross(world_tangent, in.world_normal);
|
||||||
|
|
||||||
|
// Convert the normal sample to world space
|
||||||
|
let TBN = mat3x3(
|
||||||
|
world_tangent,
|
||||||
|
world_bitangent,
|
||||||
|
in.world_normal,
|
||||||
|
);
|
||||||
|
let tangent_normal = object_normal.xyz * 2.0 - 1.0;
|
||||||
|
let world_normal = TBN * tangent_normal;
|
||||||
|
|
||||||
|
// Create the lighting vectors
|
||||||
|
let light_dir = normalize(light.position - in.world_position);
|
||||||
|
let view_dir = normalize(in.world_view_position - in.world_position);
|
||||||
|
let half_dir = normalize(view_dir + light_dir);
|
||||||
|
|
||||||
|
let diffuse_strength = max(dot(world_normal, light_dir), 0.0);
|
||||||
|
let diffuse_color = light.color * diffuse_strength;
|
||||||
|
|
||||||
|
let specular_strength = pow(max(dot(world_normal, half_dir), 0.0), 32.0);
|
||||||
|
let specular_color = specular_strength * light.color;
|
||||||
|
|
||||||
|
// NEW!
|
||||||
|
// Calculate reflections
|
||||||
|
let world_reflect = reflect(-view_dir, world_normal);
|
||||||
|
let reflection = textureSample(env_map, env_sampler, world_reflect).rgb;
|
||||||
|
let shininess = 0.1;
|
||||||
|
|
||||||
|
let result = (diffuse_color + specular_color) * object_color.xyz + reflection * shininess;
|
||||||
|
|
||||||
|
return vec4<f32>(result, object_color.a);
|
||||||
|
}
|
@ -0,0 +1,45 @@
|
|||||||
|
struct Camera {
|
||||||
|
view_pos: vec4<f32>,
|
||||||
|
view: mat4x4<f32>,
|
||||||
|
view_proj: mat4x4<f32>,
|
||||||
|
inv_proj: mat4x4<f32>,
|
||||||
|
inv_view: mat4x4<f32>,
|
||||||
|
}
|
||||||
|
@group(0) @binding(0)
|
||||||
|
var<uniform> camera: Camera;
|
||||||
|
|
||||||
|
@group(1)
|
||||||
|
@binding(0)
|
||||||
|
var env_map: texture_cube<f32>;
|
||||||
|
@group(1)
|
||||||
|
@binding(1)
|
||||||
|
var env_sampler: sampler;
|
||||||
|
|
||||||
|
struct VertexOutput {
|
||||||
|
@builtin(position) frag_position: vec4<f32>,
|
||||||
|
@location(0) clip_position: vec4<f32>,
|
||||||
|
}
|
||||||
|
|
||||||
|
@vertex
|
||||||
|
fn vs_main(
|
||||||
|
@builtin(vertex_index) id: u32,
|
||||||
|
) -> VertexOutput {
|
||||||
|
let uv = vec2<f32>(vec2<u32>(
|
||||||
|
id & 1u,
|
||||||
|
(id >> 1u) & 1u,
|
||||||
|
));
|
||||||
|
var out: VertexOutput;
|
||||||
|
out.clip_position = vec4(uv * 4.0 - 1.0, 1.0, 1.0);
|
||||||
|
out.frag_position = out.clip_position;
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
|
||||||
|
@fragment
|
||||||
|
fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
|
||||||
|
let view_pos_homogeneous = camera.inv_proj * in.clip_position;
|
||||||
|
let view_ray_direction = view_pos_homogeneous.xyz / view_pos_homogeneous.w;
|
||||||
|
var ray_direction = normalize((camera.inv_view * vec4(view_ray_direction, 0.0)).xyz);
|
||||||
|
|
||||||
|
let sample = textureSample(env_map, env_sampler, ray_direction);
|
||||||
|
return sample;
|
||||||
|
}
|
@ -0,0 +1,248 @@
|
|||||||
|
use anyhow::*;
|
||||||
|
use image::GenericImageView;
|
||||||
|
|
||||||
|
pub struct Texture {
|
||||||
|
pub texture: wgpu::Texture,
|
||||||
|
pub view: wgpu::TextureView,
|
||||||
|
pub sampler: wgpu::Sampler,
|
||||||
|
pub size: wgpu::Extent3d,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Texture {
|
||||||
|
pub const DEPTH_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Depth32Float;
|
||||||
|
|
||||||
|
pub fn create_depth_texture(
|
||||||
|
device: &wgpu::Device,
|
||||||
|
config: &wgpu::SurfaceConfiguration,
|
||||||
|
label: &str,
|
||||||
|
) -> Self {
|
||||||
|
let size = wgpu::Extent3d {
|
||||||
|
width: config.width,
|
||||||
|
height: config.height,
|
||||||
|
depth_or_array_layers: 1,
|
||||||
|
};
|
||||||
|
let desc = wgpu::TextureDescriptor {
|
||||||
|
label: Some(label),
|
||||||
|
size,
|
||||||
|
mip_level_count: 1,
|
||||||
|
sample_count: 1,
|
||||||
|
dimension: wgpu::TextureDimension::D2,
|
||||||
|
format: Self::DEPTH_FORMAT,
|
||||||
|
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
|
||||||
|
view_formats: &[Self::DEPTH_FORMAT],
|
||||||
|
};
|
||||||
|
let texture = device.create_texture(&desc);
|
||||||
|
let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
|
||||||
|
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
|
||||||
|
address_mode_u: wgpu::AddressMode::ClampToEdge,
|
||||||
|
address_mode_v: wgpu::AddressMode::ClampToEdge,
|
||||||
|
address_mode_w: wgpu::AddressMode::ClampToEdge,
|
||||||
|
mag_filter: wgpu::FilterMode::Linear,
|
||||||
|
min_filter: wgpu::FilterMode::Linear,
|
||||||
|
mipmap_filter: wgpu::FilterMode::Nearest,
|
||||||
|
compare: Some(wgpu::CompareFunction::LessEqual),
|
||||||
|
lod_min_clamp: 0.0,
|
||||||
|
lod_max_clamp: 100.0,
|
||||||
|
..Default::default()
|
||||||
|
});
|
||||||
|
|
||||||
|
Self {
|
||||||
|
texture,
|
||||||
|
view,
|
||||||
|
sampler,
|
||||||
|
size, // NEW!
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
pub fn from_bytes(
|
||||||
|
device: &wgpu::Device,
|
||||||
|
queue: &wgpu::Queue,
|
||||||
|
bytes: &[u8],
|
||||||
|
label: &str,
|
||||||
|
is_normal_map: bool,
|
||||||
|
) -> Result<Self> {
|
||||||
|
let img = image::load_from_memory(bytes)?;
|
||||||
|
Self::from_image(device, queue, &img, Some(label), is_normal_map)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn from_image(
|
||||||
|
device: &wgpu::Device,
|
||||||
|
queue: &wgpu::Queue,
|
||||||
|
img: &image::DynamicImage,
|
||||||
|
label: Option<&str>,
|
||||||
|
is_normal_map: bool,
|
||||||
|
) -> Result<Self> {
|
||||||
|
let dimensions = img.dimensions();
|
||||||
|
let rgba = img.to_rgba8();
|
||||||
|
|
||||||
|
let format = if is_normal_map {
|
||||||
|
wgpu::TextureFormat::Rgba8Unorm
|
||||||
|
} else {
|
||||||
|
wgpu::TextureFormat::Rgba8UnormSrgb
|
||||||
|
};
|
||||||
|
let usage = wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST;
|
||||||
|
let size = wgpu::Extent3d {
|
||||||
|
width: img.width(),
|
||||||
|
height: img.height(),
|
||||||
|
depth_or_array_layers: 1,
|
||||||
|
};
|
||||||
|
let texture = Self::create_2d_texture(
|
||||||
|
device,
|
||||||
|
size.width,
|
||||||
|
size.height,
|
||||||
|
format,
|
||||||
|
usage,
|
||||||
|
wgpu::FilterMode::Linear,
|
||||||
|
label,
|
||||||
|
);
|
||||||
|
|
||||||
|
queue.write_texture(
|
||||||
|
wgpu::ImageCopyTexture {
|
||||||
|
aspect: wgpu::TextureAspect::All,
|
||||||
|
texture: &texture.texture,
|
||||||
|
mip_level: 0,
|
||||||
|
origin: wgpu::Origin3d::ZERO,
|
||||||
|
},
|
||||||
|
&rgba,
|
||||||
|
wgpu::ImageDataLayout {
|
||||||
|
offset: 0,
|
||||||
|
bytes_per_row: Some(4 * dimensions.0),
|
||||||
|
rows_per_image: Some(dimensions.1),
|
||||||
|
},
|
||||||
|
size,
|
||||||
|
);
|
||||||
|
|
||||||
|
Ok(texture)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(crate) fn create_2d_texture(
|
||||||
|
device: &wgpu::Device,
|
||||||
|
width: u32,
|
||||||
|
height: u32,
|
||||||
|
format: wgpu::TextureFormat,
|
||||||
|
usage: wgpu::TextureUsages,
|
||||||
|
mag_filter: wgpu::FilterMode,
|
||||||
|
label: Option<&str>,
|
||||||
|
) -> Self {
|
||||||
|
let size = wgpu::Extent3d {
|
||||||
|
width,
|
||||||
|
height,
|
||||||
|
depth_or_array_layers: 1,
|
||||||
|
};
|
||||||
|
Self::create_texture(
|
||||||
|
device,
|
||||||
|
label,
|
||||||
|
size,
|
||||||
|
format,
|
||||||
|
usage,
|
||||||
|
wgpu::TextureDimension::D2,
|
||||||
|
mag_filter,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn create_texture(
|
||||||
|
device: &wgpu::Device,
|
||||||
|
label: Option<&str>,
|
||||||
|
size: wgpu::Extent3d,
|
||||||
|
format: wgpu::TextureFormat,
|
||||||
|
usage: wgpu::TextureUsages,
|
||||||
|
dimension: wgpu::TextureDimension,
|
||||||
|
mag_filter: wgpu::FilterMode,
|
||||||
|
) -> Self {
|
||||||
|
let texture = device.create_texture(&wgpu::TextureDescriptor {
|
||||||
|
label,
|
||||||
|
size,
|
||||||
|
mip_level_count: 1,
|
||||||
|
sample_count: 1,
|
||||||
|
dimension,
|
||||||
|
format,
|
||||||
|
usage,
|
||||||
|
view_formats: &[],
|
||||||
|
});
|
||||||
|
|
||||||
|
let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
|
||||||
|
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
|
||||||
|
address_mode_u: wgpu::AddressMode::ClampToEdge,
|
||||||
|
address_mode_v: wgpu::AddressMode::ClampToEdge,
|
||||||
|
address_mode_w: wgpu::AddressMode::ClampToEdge,
|
||||||
|
mag_filter,
|
||||||
|
min_filter: wgpu::FilterMode::Nearest,
|
||||||
|
mipmap_filter: wgpu::FilterMode::Nearest,
|
||||||
|
..Default::default()
|
||||||
|
});
|
||||||
|
|
||||||
|
Self {
|
||||||
|
texture,
|
||||||
|
view,
|
||||||
|
sampler,
|
||||||
|
size, // NEW!
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub struct CubeTexture {
|
||||||
|
texture: wgpu::Texture,
|
||||||
|
sampler: wgpu::Sampler,
|
||||||
|
view: wgpu::TextureView,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl CubeTexture {
|
||||||
|
pub fn create_2d(
|
||||||
|
device: &wgpu::Device,
|
||||||
|
width: u32,
|
||||||
|
height: u32,
|
||||||
|
format: wgpu::TextureFormat,
|
||||||
|
mip_level_count: u32,
|
||||||
|
usage: wgpu::TextureUsages,
|
||||||
|
mag_filter: wgpu::FilterMode,
|
||||||
|
label: Option<&str>,
|
||||||
|
) -> Self {
|
||||||
|
let texture = device.create_texture(&wgpu::TextureDescriptor {
|
||||||
|
label,
|
||||||
|
size: wgpu::Extent3d {
|
||||||
|
width,
|
||||||
|
height,
|
||||||
|
// A cube has 6 sides, so we need 6 layers
|
||||||
|
depth_or_array_layers: 6,
|
||||||
|
},
|
||||||
|
mip_level_count,
|
||||||
|
sample_count: 1,
|
||||||
|
dimension: wgpu::TextureDimension::D2,
|
||||||
|
format,
|
||||||
|
usage,
|
||||||
|
view_formats: &[],
|
||||||
|
});
|
||||||
|
|
||||||
|
let view = texture.create_view(&wgpu::TextureViewDescriptor {
|
||||||
|
label,
|
||||||
|
dimension: Some(wgpu::TextureViewDimension::Cube),
|
||||||
|
array_layer_count: Some(6),
|
||||||
|
..Default::default()
|
||||||
|
});
|
||||||
|
|
||||||
|
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
|
||||||
|
label,
|
||||||
|
address_mode_u: wgpu::AddressMode::ClampToEdge,
|
||||||
|
address_mode_v: wgpu::AddressMode::ClampToEdge,
|
||||||
|
address_mode_w: wgpu::AddressMode::ClampToEdge,
|
||||||
|
mag_filter,
|
||||||
|
min_filter: wgpu::FilterMode::Nearest,
|
||||||
|
mipmap_filter: wgpu::FilterMode::Nearest,
|
||||||
|
..Default::default()
|
||||||
|
});
|
||||||
|
|
||||||
|
Self {
|
||||||
|
texture,
|
||||||
|
sampler,
|
||||||
|
view,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn texture(&self) -> &wgpu::Texture { &self.texture }
|
||||||
|
|
||||||
|
pub fn view(&self) -> &wgpu::TextureView { &self.view }
|
||||||
|
|
||||||
|
pub fn sampler(&self) -> &wgpu::Sampler { &self.sampler }
|
||||||
|
|
||||||
|
}
|
@ -0,0 +1,18 @@
|
|||||||
|
use anyhow::*;
|
||||||
|
use fs_extra::copy_items;
|
||||||
|
use fs_extra::dir::CopyOptions;
|
||||||
|
use std::env;
|
||||||
|
|
||||||
|
fn main() -> Result<()> {
|
||||||
|
// This tells cargo to rerun this script if something in /res/ changes.
|
||||||
|
println!("cargo:rerun-if-changed=res/*");
|
||||||
|
|
||||||
|
let out_dir = env::var("OUT_DIR")?;
|
||||||
|
let mut copy_options = CopyOptions::new();
|
||||||
|
copy_options.overwrite = true;
|
||||||
|
let mut paths_to_copy = Vec::new();
|
||||||
|
paths_to_copy.push("res/");
|
||||||
|
copy_items(&paths_to_copy, out_dir, ©_options)?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
@ -0,0 +1,29 @@
|
|||||||
|
<!DOCTYPE html>
|
||||||
|
<html lang="en">
|
||||||
|
|
||||||
|
<head>
|
||||||
|
<meta charset="UTF-8">
|
||||||
|
<meta http-equiv="X-UA-Compatible" content="IE=edge">
|
||||||
|
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||||
|
<title>Pong with WASM</title>
|
||||||
|
</head>
|
||||||
|
|
||||||
|
<body>
|
||||||
|
<div id="wasm-example"></div>
|
||||||
|
<script type="module">
|
||||||
|
import init from "./pkg/tutorial12_camera.js";
|
||||||
|
init().then(() => {
|
||||||
|
console.log("WASM Loaded");
|
||||||
|
});
|
||||||
|
</script>
|
||||||
|
<style>
|
||||||
|
body {
|
||||||
|
background-color: #444;
|
||||||
|
}
|
||||||
|
canvas {
|
||||||
|
background-color: black;
|
||||||
|
}
|
||||||
|
</style>
|
||||||
|
</body>
|
||||||
|
|
||||||
|
</html>
|
After Width: | Height: | Size: 1.1 MiB |
After Width: | Height: | Size: 2.1 MiB |
After Width: | Height: | Size: 25 KiB |
After Width: | Height: | Size: 117 KiB |
@ -0,0 +1,14 @@
|
|||||||
|
# Blender MTL File: 'cube.blend'
|
||||||
|
# Material Count: 1
|
||||||
|
|
||||||
|
newmtl Material.001
|
||||||
|
Ns 323.999994
|
||||||
|
Ka 1.000000 1.000000 1.000000
|
||||||
|
Kd 0.800000 0.800000 0.800000
|
||||||
|
Ks 0.500000 0.500000 0.500000
|
||||||
|
Ke 0.000000 0.000000 0.000000
|
||||||
|
Ni 1.450000
|
||||||
|
d 1.000000
|
||||||
|
illum 2
|
||||||
|
map_Bump cube-normal.png
|
||||||
|
map_Kd cube-diffuse.jpg
|
Before Width: | Height: | Size: 8.9 MiB After Width: | Height: | Size: 8.9 MiB |
Before Width: | Height: | Size: 1023 KiB After Width: | Height: | Size: 1023 KiB |
Before Width: | Height: | Size: 1014 KiB After Width: | Height: | Size: 1014 KiB |
Before Width: | Height: | Size: 15 KiB After Width: | Height: | Size: 15 KiB |
Before Width: | Height: | Size: 9.5 MiB After Width: | Height: | Size: 9.5 MiB |
Before Width: | Height: | Size: 3.2 MiB After Width: | Height: | Size: 3.2 MiB |