Compare commits

..

55 Commits

Author SHA1 Message Date
1d9d4efedb do not step physics on mouse input, only update pos (overwriting previous pos) 2023-09-20 22:31:26 -07:00
bd04f680d8 fix angles 2023-09-20 22:31:26 -07:00
46cc082c07 accumulate deltas 2023-09-20 22:31:26 -07:00
55fcdb8e27 implement jump() + remove jump_trying + prevent air jumping 2023-09-20 22:31:26 -07:00
d7df468388 wip 2 2023-09-20 22:31:26 -07:00
990199b4c7 wip 2023-09-20 22:31:26 -07:00
1de3501e89 no default transform 2023-09-20 22:29:46 -07:00
0135b17917 make proper model data and stop passing device into add_obj 2023-09-20 22:29:33 -07:00
1878528a4f v0.4.0 instanced rendering + model textures 2023-09-20 17:45:39 -07:00
25e80a7c17 scope skybox 2023-09-20 17:13:08 -07:00
21835d13f6 load squid texture 2023-09-20 17:13:08 -07:00
91f6a5261f move camera_uniforms and skybox_texture 2023-09-20 17:13:08 -07:00
fb4a5efa14 split main bind group, rename everything, organize GraphicsData 2023-09-20 17:13:08 -07:00
acb658f3e9 goal: repeating ground texture 2023-09-20 14:07:11 -07:00
7e427b3879 instanced rendering 2023-09-20 13:48:07 -07:00
d16485ae6d replace visual ground with custom ground model! 2023-09-20 13:37:46 -07:00
cdf695ee6e label bind group 2023-09-20 13:02:47 -07:00
5fc4044284 small physics opti 2023-09-19 18:14:24 -07:00
6f4fda8cc0 clip walk target velocity in RefreshWalkTarget 2023-09-19 17:54:43 -07:00
d58f915082 v0.3.0 physics + walking 2023-09-19 01:21:00 -07:00
8e95fe484a unnecessary cast 2023-09-19 00:58:35 -07:00
5854128164 edit comments 2023-09-19 00:00:14 -07:00
db5b3328bd update time for extern instructions 2023-09-19 00:00:06 -07:00
4951d1513d stop skipping over time 2023-09-18 23:57:42 -07:00
17e71d884f SetControlDir + contact constrain + walk.state enum instead of hash 2023-09-18 23:36:14 -07:00
1dc98d9c2d stupid mistake 2023-09-18 23:33:52 -07:00
fd38502e07 only walk if grounded 2023-09-18 21:28:09 -07:00
0632e322cf implement walk with hashing lole!! 2023-09-18 21:10:07 -07:00
7544c6e6ef fix roblox camera offset 2023-09-18 19:47:15 -07:00
2f0a073fd5 fix aabb normals + face_mesh 2023-09-18 19:04:32 -07:00
21dc425fc2 edit comments 2023-09-18 19:04:32 -07:00
ca141c800c debug print instructions 2023-09-18 19:04:32 -07:00
63ce06f069 syntactic sugar 2023-09-18 18:31:15 -07:00
fe14d5e0fa worthless opti 2023-09-18 18:31:04 -07:00
bffc254a0d put -t back 2023-09-18 18:27:02 -07:00
a5f203484b comment on CollisionEnd handling 2023-09-18 18:08:03 -07:00
e67479a9bd TEMP: move jump out 2023-09-18 18:08:03 -07:00
ad7abbdf1c rework predict_collision_end 2023-09-18 18:08:03 -07:00
3a0b3900ec fix falling 2023-09-18 16:04:55 -07:00
765ed42b9d start in air 2023-09-18 16:04:55 -07:00
8137a26f81 standardize vec init 2023-09-18 16:04:55 -07:00
21ae7a0e4f use pva for init 2023-09-18 16:04:55 -07:00
5a886b76d1 comment about processed_time 2023-09-18 16:04:55 -07:00
f1e26cb07a don't print frame delta 2023-09-18 16:04:55 -07:00
14a74c6e1e consume vec 2023-09-18 16:04:55 -07:00
5b55873bd5 halfsize 2023-09-18 16:04:55 -07:00
fd5d71e1af use hashset for contacts 2023-09-18 16:04:55 -07:00
28c3f21736 implement aabb collision 2023-09-18 16:04:55 -07:00
a58464efb0 how will I do this 2023-09-18 15:49:09 -07:00
b070b9706f InputState 2023-09-18 15:49:09 -07:00
dcfbee8de1 MouseInterpolationState 2023-09-18 15:49:09 -07:00
c5636f7fcd delete unused 2023-09-18 15:26:21 -07:00
a5aa89064b next_instruction non-optional time_limit 2023-09-18 15:26:21 -07:00
0fe14749d3 wip: tickless physics 2023-09-18 15:26:21 -07:00
8daf432991 zeroes 2023-09-18 15:26:21 -07:00
8 changed files with 1011 additions and 674 deletions

2
Cargo.lock generated

@ -1405,7 +1405,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
[[package]]
name = "strafe-client"
version = "0.2.0"
version = "0.4.0"
dependencies = [
"async-executor",
"bytemuck",

@ -1,6 +1,6 @@
[package]
name = "strafe-client"
version = "0.2.0"
version = "0.4.0"
edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

BIN
images/squid.dds Normal file

Binary file not shown.

File diff suppressed because it is too large Load Diff

@ -1,12 +1,10 @@
use std::future::Future;
#[cfg(target_arch = "wasm32")]
use std::str::FromStr;
#[cfg(not(target_arch = "wasm32"))]
use std::time::Instant;
#[cfg(target_arch = "wasm32")]
use web_sys::{ImageBitmapRenderingContext, OffscreenCanvas};
use winit::{
event::{self, WindowEvent},
event::{self, WindowEvent, DeviceEvent},
event_loop::{ControlFlow, EventLoop},
};
@ -54,7 +52,7 @@ pub trait Example: 'static + Sized {
queue: &wgpu::Queue,
);
fn update(&mut self, event: WindowEvent);
fn move_mouse(&mut self, delta: (f64,f64));
fn device_event(&mut self, event: DeviceEvent);
fn render(
&mut self,
view: &wgpu::TextureView,
@ -350,13 +348,10 @@ fn start<E: Example>(
}
},
event::Event::DeviceEvent {
event:
winit::event::DeviceEvent::MouseMotion {
delta,
},
event,
..
} => {
example.move_mouse(delta);
example.device_event(event);
},
event::Event::RedrawRequested(_) => {

@ -1,10 +1,11 @@
#[derive(Debug)]
pub struct TimedInstruction<I> {
pub time: crate::body::TIME,
pub instruction: I,
}
pub trait InstructionEmitter<I> {
fn next_instruction(&self, time:crate::body::TIME) -> Option<TimedInstruction<I>>;
fn next_instruction(&self, time_limit:crate::body::TIME) -> Option<TimedInstruction<I>>;
}
pub trait InstructionConsumer<I> {
fn process_instruction(&mut self, instruction:TimedInstruction<I>);

@ -1,4 +1,5 @@
use bytemuck::{Pod, Zeroable};
use strafe_client::{instruction::{TimedInstruction, InstructionConsumer},body::{InputInstruction, PhysicsInstruction}};
use std::{borrow::Cow, time::Instant};
use wgpu::{util::DeviceExt, AstcBlock, AstcChannel};
@ -17,117 +18,42 @@ struct Entity {
index_buf: wgpu::Buffer,
}
//temp?
struct ModelData {
transform: glam::Mat4,
vertex_buf: wgpu::Buffer,
entities: Vec<Entity>,
transforms: Vec<glam::Mat4>,
vertices: Vec<Vertex>,
entities: Vec<Vec<u16>>,
}
struct ModelGraphics {
transform: glam::Mat4,
transforms: Vec<glam::Mat4>,
vertex_buf: wgpu::Buffer,
entities: Vec<Entity>,
bind_group: wgpu::BindGroup,
model_buf: wgpu::Buffer,
}
// Note: we use the Y=up coordinate space in this example.
struct Camera {
screen_size: (u32, u32),
offset: glam::Vec3,
fov: f32,
yaw: f32,
pitch: f32,
controls: u32,
pub struct GraphicsBindGroups {
camera: wgpu::BindGroup,
skybox_texture: wgpu::BindGroup,
}
const CONTROL_MOVEFORWARD:u32 = 0b00000001;
const CONTROL_MOVEBACK:u32 = 0b00000010;
const CONTROL_MOVERIGHT:u32 = 0b00000100;
const CONTROL_MOVELEFT:u32 = 0b00001000;
const CONTROL_MOVEUP:u32 = 0b00010000;
const CONTROL_MOVEDOWN:u32 = 0b00100000;
const CONTROL_JUMP:u32 = 0b01000000;
const CONTROL_ZOOM:u32 = 0b10000000;
const FORWARD_DIR:glam::Vec3 = glam::Vec3::new(0.0,0.0,-1.0);
const RIGHT_DIR:glam::Vec3 = glam::Vec3::new(1.0,0.0,0.0);
const UP_DIR:glam::Vec3 = glam::Vec3::new(0.0,1.0,0.0);
fn get_control_dir(controls: u32) -> glam::Vec3{
//don't get fancy just do it
let mut control_dir:glam::Vec3 = glam::Vec3::new(0.0,0.0,0.0);
if controls & CONTROL_MOVEFORWARD == CONTROL_MOVEFORWARD {
control_dir+=FORWARD_DIR;
}
if controls & CONTROL_MOVEBACK == CONTROL_MOVEBACK {
control_dir+=-FORWARD_DIR;
}
if controls & CONTROL_MOVELEFT == CONTROL_MOVELEFT {
control_dir+=-RIGHT_DIR;
}
if controls & CONTROL_MOVERIGHT == CONTROL_MOVERIGHT {
control_dir+=RIGHT_DIR;
}
if controls & CONTROL_MOVEUP == CONTROL_MOVEUP {
control_dir+=UP_DIR;
}
if controls & CONTROL_MOVEDOWN == CONTROL_MOVEDOWN {
control_dir+=-UP_DIR;
}
return control_dir
pub struct GraphicsPipelines {
skybox: wgpu::RenderPipeline,
model: wgpu::RenderPipeline,
}
#[inline]
fn perspective_rh(fov_y_slope: f32, aspect_ratio: f32, z_near: f32, z_far: f32) -> glam::Mat4 {
//glam_assert!(z_near > 0.0 && z_far > 0.0);
let r = z_far / (z_near - z_far);
glam::Mat4::from_cols(
glam::Vec4::new(1.0/(fov_y_slope * aspect_ratio), 0.0, 0.0, 0.0),
glam::Vec4::new(0.0, 1.0/fov_y_slope, 0.0, 0.0),
glam::Vec4::new(0.0, 0.0, r, -1.0),
glam::Vec4::new(0.0, 0.0, r * z_near, 0.0),
)
}
impl Camera {
fn to_uniform_data(&self, pos: glam::Vec3) -> [f32; 16 * 3 + 4] {
let aspect = self.screen_size.0 as f32 / self.screen_size.1 as f32;
let fov = if self.controls&CONTROL_ZOOM==0 {
self.fov
}else{
self.fov/5.0
};
let proj = perspective_rh(fov, aspect, 0.5, 1000.0);
let proj_inv = proj.inverse();
let view = glam::Mat4::from_translation(pos+self.offset) * glam::Mat4::from_euler(glam::EulerRot::YXZ, self.yaw, self.pitch, 0f32);
let view_inv = view.inverse();
let mut raw = [0f32; 16 * 3 + 4];
raw[..16].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&proj)[..]);
raw[16..32].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&proj_inv)[..]);
raw[32..48].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&view_inv)[..]);
raw[48..52].copy_from_slice(AsRef::<[f32; 4]>::as_ref(&view.col(3)));
raw
}
}
pub struct Skybox {
pub struct GraphicsData {
start_time: std::time::Instant,
camera: Camera,
screen_size: (u32, u32),
physics: strafe_client::body::PhysicsState,
sky_pipeline: wgpu::RenderPipeline,
entity_pipeline: wgpu::RenderPipeline,
ground_pipeline: wgpu::RenderPipeline,
main_bind_group: wgpu::BindGroup,
pipelines: GraphicsPipelines,
bind_groups: GraphicsBindGroups,
camera_buf: wgpu::Buffer,
models: Vec<ModelGraphics>,
depth_view: wgpu::TextureView,
staging_belt: wgpu::util::StagingBelt,
}
impl Skybox {
impl GraphicsData {
const DEPTH_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Depth24Plus;
fn create_depth_texture(
@ -153,18 +79,24 @@ impl Skybox {
}
}
fn get_transform_uniform_data(transform:&glam::Mat4) -> [f32; 4*4] {
let mut raw = [0f32; 4*4];
raw[0..16].copy_from_slice(&AsRef::<[f32; 4*4]>::as_ref(transform)[..]);
fn get_transform_uniform_data(transforms:&Vec<glam::Mat4>) -> Vec<f32> {
let mut raw = Vec::with_capacity(4*4*transforms.len());
for (i,t) in transforms.iter().enumerate(){
let mut v = raw.split_off(4*4*i);
raw.extend_from_slice(&AsRef::<[f32; 4*4]>::as_ref(t)[..]);
raw.append(&mut v);
}
raw
}
fn add_obj(device:&wgpu::Device,modeldatas:& mut Vec<ModelData>,source:&[u8]){
let data = obj::ObjData::load_buf(&source[..]).unwrap();
fn generate_modeldatas(data:obj::ObjData) -> Vec<ModelData>{
let mut modeldatas=Vec::new();
let mut vertices = Vec::new();
let mut vertex_index = std::collections::HashMap::<obj::IndexTuple,u16>::new();
for object in data.objects {
let mut entities = Vec::<Entity>::new();
vertices.clear();
vertex_index.clear();
let mut entities = Vec::new();
for group in object.groups {
let mut indices = Vec::new();
for poly in group.polys {
@ -172,7 +104,7 @@ fn add_obj(device:&wgpu::Device,modeldatas:& mut Vec<ModelData>,source:&[u8]){
for &index in &[0, end_index - 1, end_index] {
let vert = poly.0[index];
if let Some(&i)=vertex_index.get(&vert){
indices.push(i as u16);
indices.push(i);
}else{
let i=vertices.len() as u16;
vertices.push(Vertex {
@ -186,30 +118,33 @@ fn add_obj(device:&wgpu::Device,modeldatas:& mut Vec<ModelData>,source:&[u8]){
}
}
}
let index_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Index"),
contents: bytemuck::cast_slice(&indices),
usage: wgpu::BufferUsages::INDEX,
});
entities.push(Entity {
index_buf,
index_count: indices.len() as u32,
});
entities.push(indices);
}
let vertex_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Vertex"),
contents: bytemuck::cast_slice(&vertices),
usage: wgpu::BufferUsages::VERTEX,
});
modeldatas.push(ModelData {
transform: glam::Mat4::default(),
vertex_buf,
transforms: vec![],
vertices:vertices.clone(),
entities,
})
});
}
modeldatas
}
impl strafe_client::framework::Example for Skybox {
fn to_uniform_data(camera: &strafe_client::body::Camera, pos: glam::Vec3) -> [f32; 16 * 3 + 4] {
let proj=camera.proj();
let proj_inv = proj.inverse();
let view=camera.view(pos);
let view_inv = view.inverse();
let mut raw = [0f32; 16 * 3 + 4];
raw[..16].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&proj)[..]);
raw[16..32].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&proj_inv)[..]);
raw[32..48].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&view_inv)[..]);
raw[48..52].copy_from_slice(AsRef::<[f32; 4]>::as_ref(&view.col(3)));
raw
}
impl strafe_client::framework::Example for GraphicsData {
fn optional_features() -> wgpu::Features {
wgpu::Features::TEXTURE_COMPRESSION_ASTC
| wgpu::Features::TEXTURE_COMPRESSION_ETC2
@ -222,16 +157,78 @@ impl strafe_client::framework::Example for Skybox {
device: &wgpu::Device,
queue: &wgpu::Queue,
) -> Self {
let ground=obj::ObjData{
position: vec![[-1.0,0.0,-1.0],[1.0,0.0,-1.0],[1.0,0.0,1.0],[-1.0,0.0,1.0]],
texture: vec![[-10.0,-10.0],[10.0,-10.0],[10.0,10.0],[-10.0,10.0]],
normal: vec![[0.0,1.0,0.0]],
objects: vec![obj::Object{
name: "Ground Object".to_owned(),
groups: vec![obj::Group{
name: "Ground Group".to_owned(),
index: 0,
material: None,
polys: vec![obj::SimplePolygon(vec![
obj::IndexTuple(0,Some(0),Some(0)),
obj::IndexTuple(1,Some(1),Some(0)),
obj::IndexTuple(2,Some(2),Some(0)),
obj::IndexTuple(3,Some(3),Some(0)),
])]
}]
}],
material_libs: Vec::new(),
};
let mut modeldatas = Vec::<ModelData>::new();
add_obj(device,& mut modeldatas,include_bytes!("../models/teslacyberv3.0.obj"));
add_obj(device,& mut modeldatas,include_bytes!("../models/suzanne.obj"));
add_obj(device,& mut modeldatas,include_bytes!("../models/teapot.obj"));
modeldatas.append(&mut generate_modeldatas(obj::ObjData::load_buf(&include_bytes!("../models/teslacyberv3.0.obj")[..]).unwrap()));
modeldatas.append(&mut generate_modeldatas(obj::ObjData::load_buf(&include_bytes!("../models/suzanne.obj")[..]).unwrap()));
modeldatas.append(&mut generate_modeldatas(obj::ObjData::load_buf(&include_bytes!("../models/teapot.obj")[..]).unwrap()));
modeldatas.append(&mut generate_modeldatas(ground));
println!("models.len = {:?}", modeldatas.len());
modeldatas[1].transform=glam::Mat4::from_translation(glam::vec3(10.,5.,10.));
modeldatas[2].transform=glam::Mat4::from_translation(glam::vec3(-10.,5.,10.));
modeldatas[0].transforms.push(glam::Mat4::from_translation(glam::vec3(10.,0.,-10.)));
modeldatas[1].transforms.push(glam::Mat4::from_translation(glam::vec3(10.,5.,10.)));
modeldatas[1].transforms.push(glam::Mat4::from_translation(glam::vec3(20.,5.,10.)));
modeldatas[1].transforms.push(glam::Mat4::from_translation(glam::vec3(10.,5.,20.)));
modeldatas[1].transforms.push(glam::Mat4::from_translation(glam::vec3(20.,5.,20.)));
modeldatas[2].transforms.push(glam::Mat4::from_translation(glam::vec3(-10.,5.,10.)));
modeldatas[3].transforms.push(glam::Mat4::from_translation(glam::vec3(0.,0.,0.))*glam::Mat4::from_scale(glam::vec3(160.0, 1.0, 160.0)));
let main_bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
let camera_bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: None,
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
},
],
});
let skybox_texture_bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("Skybox Texture Bind Group Layout"),
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
multisampled: false,
view_dimension: wgpu::TextureViewDimension::Cube,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
count: None,
},
],
});
let model_bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("Model Bind Group Layout"),
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
@ -249,7 +246,7 @@ impl strafe_client::framework::Example for Skybox {
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
multisampled: false,
view_dimension: wgpu::TextureViewDimension::Cube,
view_dimension: wgpu::TextureViewDimension::D2,
},
count: None,
},
@ -261,20 +258,26 @@ impl strafe_client::framework::Example for Skybox {
},
],
});
let model_bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: None,
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
},
],
let clamp_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("Clamp Sampler"),
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::Linear,
..Default::default()
});
let repeat_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("Repeat Sampler"),
address_mode_u: wgpu::AddressMode::Repeat,
address_mode_v: wgpu::AddressMode::Repeat,
address_mode_w: wgpu::AddressMode::Repeat,
mag_filter: wgpu::FilterMode::Linear,
min_filter: wgpu::FilterMode::Linear,
mipmap_filter: wgpu::FilterMode::Linear,
..Default::default()
});
// Create the render pipeline
@ -283,44 +286,147 @@ impl strafe_client::framework::Example for Skybox {
source: wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("shader.wgsl"))),
});
let camera = Camera {
screen_size: (config.width, config.height),
offset: glam::Vec3::new(0.0,4.5,0.0),
fov: 1.0, //fov_slope = tan(fov_y/2)
pitch: 0.0,
yaw: 0.0,
controls:0,
};
let physics = strafe_client::body::PhysicsState {
body: strafe_client::body::Body::with_position(glam::Vec3::new(5.0,2.0,5.0)),
body: strafe_client::body::Body::with_pva(glam::vec3(0.0,50.0,0.0),glam::vec3(0.0,0.0,0.0),glam::vec3(0.0,-100.0,0.0)),
time: 0,
tick: 0,
strafe_tick_num: 100,//100t
strafe_tick_den: 1_000_000_000,
gravity: glam::Vec3::new(0.0,-100.0,0.0),
friction: 90.0,
gravity: glam::vec3(0.0,-100.0,0.0),
friction: 1.2,
walk_accel: 90.0,
mv: 2.7,
grounded: false,
jump_trying: false,
temp_control_dir: glam::Vec3::ZERO,
walkspeed: 18.0,
contacts: std::collections::HashSet::new(),
models_cringe_clone: modeldatas.iter().map(|m|strafe_client::body::Model::new(m.transform)).collect(),
walk_target_velocity: glam::Vec3::ZERO,
hitbox_halfsize: glam::vec3(1.0,2.5,1.0),
models_cringe_clone: modeldatas.iter().map(|m|m.transforms.iter().map(|t|strafe_client::body::Model::new(*t))).flatten().collect(),
walk: strafe_client::body::WalkState::new(),
hitbox_halfsize: glam::vec3(1.0,2.5,1.0),
camera: strafe_client::body::Camera::from_offset(glam::vec3(0.0,4.5-2.5,0.0),(config.width as f32)/(config.height as f32)),
mouse_interpolation: strafe_client::body::MouseInterpolationState::new(),
controls: 0,
};
let camera_uniforms = camera.to_uniform_data(physics.body.extrapolated_position(0));
let camera_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Camera"),
contents: bytemuck::cast_slice(&camera_uniforms),
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
});
//load textures
let device_features = device.features();
let skybox_texture_view={
let skybox_format = if device_features.contains(wgpu::Features::TEXTURE_COMPRESSION_ASTC) {
log::info!("Using ASTC");
wgpu::TextureFormat::Astc {
block: AstcBlock::B4x4,
channel: AstcChannel::UnormSrgb,
}
} else if device_features.contains(wgpu::Features::TEXTURE_COMPRESSION_ETC2) {
log::info!("Using ETC2");
wgpu::TextureFormat::Etc2Rgb8UnormSrgb
} else if device_features.contains(wgpu::Features::TEXTURE_COMPRESSION_BC) {
log::info!("Using BC");
wgpu::TextureFormat::Bc1RgbaUnormSrgb
} else {
log::info!("Using plain");
wgpu::TextureFormat::Bgra8UnormSrgb
};
let size = wgpu::Extent3d {
width: IMAGE_SIZE,
height: IMAGE_SIZE,
depth_or_array_layers: 6,
};
let layer_size = wgpu::Extent3d {
depth_or_array_layers: 1,
..size
};
let max_mips = layer_size.max_mips(wgpu::TextureDimension::D2);
log::debug!(
"Copying {:?} skybox images of size {}, {}, 6 with {} mips to gpu",
skybox_format,
IMAGE_SIZE,
IMAGE_SIZE,
max_mips,
);
let bytes = match skybox_format {
wgpu::TextureFormat::Astc {
block: AstcBlock::B4x4,
channel: AstcChannel::UnormSrgb,
} => &include_bytes!("../images/astc.dds")[..],
wgpu::TextureFormat::Etc2Rgb8UnormSrgb => &include_bytes!("../images/etc2.dds")[..],
wgpu::TextureFormat::Bc1RgbaUnormSrgb => &include_bytes!("../images/bc1.dds")[..],
wgpu::TextureFormat::Bgra8UnormSrgb => &include_bytes!("../images/bgra.dds")[..],
_ => unreachable!(),
};
let skybox_image = ddsfile::Dds::read(&mut std::io::Cursor::new(&bytes)).unwrap();
let skybox_texture = device.create_texture_with_data(
queue,
&wgpu::TextureDescriptor {
size,
mip_level_count: max_mips,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: skybox_format,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
label: Some("Skybox Texture"),
view_formats: &[],
},
&skybox_image.data,
);
skybox_texture.create_view(&wgpu::TextureViewDescriptor {
label: Some("Skybox Texture View"),
dimension: Some(wgpu::TextureViewDimension::Cube),
..wgpu::TextureViewDescriptor::default()
})
};
//squid
let squid_texture_view={
let size = wgpu::Extent3d {
width: 1076,
height: 1076,
depth_or_array_layers: 1,
};
let layer_size = wgpu::Extent3d {
depth_or_array_layers: 1,
..size
};
let max_mips = layer_size.max_mips(wgpu::TextureDimension::D2);
let bytes = &include_bytes!("../images/squid.dds")[..];
let image = ddsfile::Dds::read(&mut std::io::Cursor::new(&bytes)).unwrap();
let texture = device.create_texture_with_data(
queue,
&wgpu::TextureDescriptor {
size,
mip_level_count: max_mips,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Bc7RgbaUnorm,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
label: Some("Squid Texture"),
view_formats: &[],
},
&image.data,
);
texture.create_view(&wgpu::TextureViewDescriptor {
label: Some("Squid Texture View"),
dimension: Some(wgpu::TextureViewDimension::D2),
..wgpu::TextureViewDescriptor::default()
})
};
//drain the modeldata vec so entities can be /moved/ to models.entities
let mut models = Vec::<ModelGraphics>::with_capacity(modeldatas.len());
for (i,modeldata) in modeldatas.drain(..).enumerate() {
let model_uniforms = get_transform_uniform_data(&modeldata.transform);
let model_uniforms = get_transform_uniform_data(&modeldata.transforms);
let model_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some(format!("ModelGraphics{}",i).as_str()),
contents: bytemuck::cast_slice(&model_uniforms),
@ -333,14 +439,37 @@ impl strafe_client::framework::Example for Skybox {
binding: 0,
resource: model_buf.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(&squid_texture_view),
},
wgpu::BindGroupEntry {
binding: 2,
resource: wgpu::BindingResource::Sampler(&repeat_sampler),
},
],
label: Some(format!("ModelGraphics{}",i).as_str()),
});
let vertex_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Vertex"),
contents: bytemuck::cast_slice(&modeldata.vertices),
usage: wgpu::BufferUsages::VERTEX,
});
//all of these are being moved here
models.push(ModelGraphics{
transform: modeldata.transform,
vertex_buf:modeldata.vertex_buf,
entities: modeldata.entities,
transforms:modeldata.transforms,
vertex_buf,
entities: modeldata.entities.iter().map(|indices|{
let index_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Index"),
contents: bytemuck::cast_slice(&indices),
usage: wgpu::BufferUsages::INDEX,
});
Entity {
index_buf,
index_count: indices.len() as u32,
}
}).collect(),
bind_group: model_bind_group,
model_buf,
})
@ -348,13 +477,17 @@ impl strafe_client::framework::Example for Skybox {
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: None,
bind_group_layouts: &[&main_bind_group_layout, &model_bind_group_layout],
bind_group_layouts: &[
&camera_bind_group_layout,
&model_bind_group_layout,
&skybox_texture_bind_group_layout,
],
push_constant_ranges: &[],
});
// Create the render pipelines
let sky_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("Sky"),
label: Some("Sky Pipeline"),
layout: Some(&pipeline_layout),
vertex: wgpu::VertexState {
module: &shader,
@ -380,12 +513,12 @@ impl strafe_client::framework::Example for Skybox {
multisample: wgpu::MultisampleState::default(),
multiview: None,
});
let entity_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("Entity"),
let model_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("Model Pipeline"),
layout: Some(&pipeline_layout),
vertex: wgpu::VertexState {
module: &shader,
entry_point: "vs_entity",
entry_point: "vs_entity_texture",
buffers: &[wgpu::VertexBufferLayout {
array_stride: std::mem::size_of::<Vertex>() as wgpu::BufferAddress,
step_mode: wgpu::VertexStepMode::Vertex,
@ -394,34 +527,7 @@ impl strafe_client::framework::Example for Skybox {
},
fragment: Some(wgpu::FragmentState {
module: &shader,
entry_point: "fs_entity",
targets: &[Some(config.view_formats[0].into())],
}),
primitive: wgpu::PrimitiveState {
front_face: wgpu::FrontFace::Cw,
..Default::default()
},
depth_stencil: Some(wgpu::DepthStencilState {
format: Self::DEPTH_FORMAT,
depth_write_enabled: true,
depth_compare: wgpu::CompareFunction::LessEqual,
stencil: wgpu::StencilState::default(),
bias: wgpu::DepthBiasState::default(),
}),
multisample: wgpu::MultisampleState::default(),
multiview: None,
});
let ground_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("Ground"),
layout: Some(&pipeline_layout),
vertex: wgpu::VertexState {
module: &shader,
entry_point: "vs_ground",
buffers: &[],
},
fragment: Some(wgpu::FragmentState {
module: &shader,
entry_point: "fs_ground",
entry_point: "fs_entity_texture",
targets: &[Some(config.view_formats[0].into())],
}),
primitive: wgpu::PrimitiveState {
@ -439,118 +545,51 @@ impl strafe_client::framework::Example for Skybox {
multiview: None,
});
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
label: None,
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::Linear,
..Default::default()
let camera_uniforms = to_uniform_data(&physics.camera,physics.body.extrapolated_position(0));
let camera_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Camera"),
contents: bytemuck::cast_slice(&camera_uniforms),
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
});
let device_features = device.features();
let skybox_format = if device_features.contains(wgpu::Features::TEXTURE_COMPRESSION_ASTC) {
log::info!("Using ASTC");
wgpu::TextureFormat::Astc {
block: AstcBlock::B4x4,
channel: AstcChannel::UnormSrgb,
}
} else if device_features.contains(wgpu::Features::TEXTURE_COMPRESSION_ETC2) {
log::info!("Using ETC2");
wgpu::TextureFormat::Etc2Rgb8UnormSrgb
} else if device_features.contains(wgpu::Features::TEXTURE_COMPRESSION_BC) {
log::info!("Using BC");
wgpu::TextureFormat::Bc1RgbaUnormSrgb
} else {
log::info!("Using plain");
wgpu::TextureFormat::Bgra8UnormSrgb
};
let size = wgpu::Extent3d {
width: IMAGE_SIZE,
height: IMAGE_SIZE,
depth_or_array_layers: 6,
};
let layer_size = wgpu::Extent3d {
depth_or_array_layers: 1,
..size
};
let max_mips = layer_size.max_mips(wgpu::TextureDimension::D2);
log::debug!(
"Copying {:?} skybox images of size {}, {}, 6 with {} mips to gpu",
skybox_format,
IMAGE_SIZE,
IMAGE_SIZE,
max_mips,
);
let bytes = match skybox_format {
wgpu::TextureFormat::Astc {
block: AstcBlock::B4x4,
channel: AstcChannel::UnormSrgb,
} => &include_bytes!("../images/astc.dds")[..],
wgpu::TextureFormat::Etc2Rgb8UnormSrgb => &include_bytes!("../images/etc2.dds")[..],
wgpu::TextureFormat::Bc1RgbaUnormSrgb => &include_bytes!("../images/bc1.dds")[..],
wgpu::TextureFormat::Bgra8UnormSrgb => &include_bytes!("../images/bgra.dds")[..],
_ => unreachable!(),
};
let image = ddsfile::Dds::read(&mut std::io::Cursor::new(&bytes)).unwrap();
let texture = device.create_texture_with_data(
queue,
&wgpu::TextureDescriptor {
size,
mip_level_count: max_mips,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: skybox_format,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
label: None,
view_formats: &[],
},
&image.data,
);
let texture_view = texture.create_view(&wgpu::TextureViewDescriptor {
label: None,
dimension: Some(wgpu::TextureViewDimension::Cube),
..wgpu::TextureViewDescriptor::default()
});
let main_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &main_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_buf.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(&texture_view),
},
wgpu::BindGroupEntry {
binding: 2,
resource: wgpu::BindingResource::Sampler(&sampler),
},
],
label: Some("Camera"),
});
let skybox_texture_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &skybox_texture_bind_group_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(&skybox_texture_view),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::Sampler(&clamp_sampler),
},
],
label: Some("Sky Texture"),
});
let depth_view = Self::create_depth_texture(config, device);
Skybox {
GraphicsData {
start_time: Instant::now(),
camera,
screen_size: (config.width,config.height),
physics,
sky_pipeline,
entity_pipeline,
ground_pipeline,
main_bind_group,
pipelines:GraphicsPipelines{
skybox:sky_pipeline,
model:model_pipeline
},
bind_groups:GraphicsBindGroups{
camera:camera_bind_group,
skybox_texture:skybox_texture_bind_group,
},
camera_buf,
models,
depth_view,
@ -560,59 +599,67 @@ impl strafe_client::framework::Example for Skybox {
#[allow(clippy::single_match)]
fn update(&mut self, event: winit::event::WindowEvent) {
match event {
winit::event::WindowEvent::KeyboardInput {
input:
winit::event::KeyboardInput {
state,
virtual_keycode: Some(keycode),
..
},
..
} => {
match (state,keycode) {
(k,winit::event::VirtualKeyCode::W) => match k {
winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVEFORWARD,
winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVEFORWARD,
}
(k,winit::event::VirtualKeyCode::A) => match k {
winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVELEFT,
winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVELEFT,
}
(k,winit::event::VirtualKeyCode::S) => match k {
winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVEBACK,
winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVEBACK,
}
(k,winit::event::VirtualKeyCode::D) => match k {
winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVERIGHT,
winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVERIGHT,
}
(k,winit::event::VirtualKeyCode::E) => match k {
winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVEUP,
winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVEUP,
}
(k,winit::event::VirtualKeyCode::Q) => match k {
winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVEDOWN,
winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVEDOWN,
}
(k,winit::event::VirtualKeyCode::Space) => match k {
winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_JUMP,
winit::event::ElementState::Released => self.camera.controls&=!CONTROL_JUMP,
}
(k,winit::event::VirtualKeyCode::Z) => match k {
winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_ZOOM,
winit::event::ElementState::Released => self.camera.controls&=!CONTROL_ZOOM,
}
_ => (),
}
}
_ => {}
}
//nothing atm
}
fn move_mouse(&mut self, delta: (f64,f64)) {
self.camera.pitch=(self.camera.pitch as f64+delta.1/-2048.) as f32;
self.camera.yaw=(self.camera.yaw as f64+delta.0/-2048.) as f32;
fn device_event(&mut self, event: winit::event::DeviceEvent) {
//there's no way this is the best way get a timestamp.
let time=self.start_time.elapsed().as_nanos() as i64;
match event {
winit::event::DeviceEvent::Key(winit::event::KeyboardInput {
state,
scancode: keycode,
..
}) => {
let s=match state {
winit::event::ElementState::Pressed => true,
winit::event::ElementState::Released => false,
};
if let Some(input_instruction)=match keycode {
17 => Some(InputInstruction::MoveForward(s)),//W
30 => Some(InputInstruction::MoveLeft(s)),//A
31 => Some(InputInstruction::MoveBack(s)),//S
32 => Some(InputInstruction::MoveRight(s)),//D
18 => Some(InputInstruction::MoveUp(s)),//E
16 => Some(InputInstruction::MoveDown(s)),//Q
57 => Some(InputInstruction::Jump(s)),//Space
44 => Some(InputInstruction::Zoom(s)),//Z
19 => if s{Some(InputInstruction::Reset)}else{None},//R
_ => None,
}
{
self.physics.run(time);
self.physics.process_instruction(TimedInstruction{
time,
instruction:PhysicsInstruction::Input(input_instruction),
})
}
},
winit::event::DeviceEvent::MouseMotion {
delta,//these (f64,f64) are integers on my machine
} => {
//do not step the physics because the mouse polling rate is higher than the physics can run.
//essentially the previous input will be overwritten until a true step runs
//which is fine because they run all the time.
self.physics.process_instruction(TimedInstruction{
time,
instruction:PhysicsInstruction::Input(InputInstruction::MoveMouse(glam::ivec2(delta.0 as i32,delta.1 as i32))),
})
},
winit::event::DeviceEvent::MouseWheel {
delta,
} => {
println!("mousewheel{:?}",delta);
if true{//self.physics.use_scroll
self.physics.run(time);
self.physics.process_instruction(TimedInstruction{
time,
instruction:PhysicsInstruction::Input(InputInstruction::Jump(true)),//activates the immediate jump path, but the style modifier prevents controls&CONTROL_JUMP bit from being set to auto jump
})
}
}
_=>(),
}
}
fn resize(
@ -622,7 +669,8 @@ impl strafe_client::framework::Example for Skybox {
_queue: &wgpu::Queue,
) {
self.depth_view = Self::create_depth_texture(config, device);
self.camera.screen_size = (config.width, config.height);
self.screen_size = (config.width, config.height);
self.physics.camera.set_fov_aspect(1.0,(config.width as f32)/(config.height as f32));
}
fn render(
@ -632,20 +680,15 @@ impl strafe_client::framework::Example for Skybox {
queue: &wgpu::Queue,
_spawner: &strafe_client::framework::Spawner,
) {
let camera_mat=glam::Mat3::from_euler(glam::EulerRot::YXZ,self.camera.yaw,0f32,0f32);
let control_dir=camera_mat*get_control_dir(self.camera.controls&(CONTROL_MOVELEFT|CONTROL_MOVERIGHT|CONTROL_MOVEFORWARD|CONTROL_MOVEBACK)).normalize_or_zero();
let time=self.start_time.elapsed().as_nanos() as i64;
self.physics.temp_control_dir=control_dir;
self.physics.jump_trying=self.camera.controls&CONTROL_JUMP!=0;
self.physics.run(time);
let mut encoder =
device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
// update rotation
let camera_uniforms = self.camera.to_uniform_data(self.physics.body.extrapolated_position(time));
let camera_uniforms = to_uniform_data(&self.physics.camera,self.physics.body.extrapolated_position(time));
self.staging_belt
.write_buffer(
&mut encoder,
@ -657,7 +700,7 @@ impl strafe_client::framework::Example for Skybox {
.copy_from_slice(bytemuck::cast_slice(&camera_uniforms));
//This code only needs to run when the uniforms change
for model in self.models.iter() {
let model_uniforms = get_transform_uniform_data(&model.transform);
let model_uniforms = get_transform_uniform_data(&model.transforms);
self.staging_belt
.write_buffer(
&mut encoder,
@ -696,25 +739,21 @@ impl strafe_client::framework::Example for Skybox {
}),
});
rpass.set_bind_group(0, &self.main_bind_group, &[]);
rpass.set_bind_group(0, &self.bind_groups.camera, &[]);
rpass.set_bind_group(2, &self.bind_groups.skybox_texture, &[]);
rpass.set_pipeline(&self.entity_pipeline);
rpass.set_pipeline(&self.pipelines.model);
for model in self.models.iter() {
rpass.set_bind_group(1, &model.bind_group, &[]);
rpass.set_vertex_buffer(0, model.vertex_buf.slice(..));
for entity in model.entities.iter() {
rpass.set_index_buffer(entity.index_buf.slice(..), wgpu::IndexFormat::Uint16);
rpass.draw_indexed(0..entity.index_count, 0, 0..1);
rpass.draw_indexed(0..entity.index_count, 0, 0..model.transforms.len() as u32);
}
}
rpass.set_pipeline(&self.ground_pipeline);
//rpass.set_index_buffer(&[0u16,1,2,1,2,3][..] as wgpu::BufferSlice, wgpu::IndexFormat::Uint16);
//rpass.draw_indexed(0..4, 0, 0..1);
rpass.draw(0..6, 0..1);
rpass.set_pipeline(&self.sky_pipeline);
rpass.set_pipeline(&self.pipelines.skybox);
rpass.draw(0..3, 0..1);
}
@ -725,7 +764,7 @@ impl strafe_client::framework::Example for Skybox {
}
fn main() {
strafe_client::framework::run::<Skybox>(
strafe_client::framework::run::<GraphicsData>(
format!("Strafe Client v{}",
env!("CARGO_PKG_VERSION")
).as_str()

@ -1,9 +1,4 @@
struct SkyOutput {
@builtin(position) position: vec4<f32>,
@location(0) sampledir: vec3<f32>,
};
struct Data {
struct Camera {
// from camera to screen
proj: mat4x4<f32>,
// from screen to camera
@ -13,9 +8,16 @@ struct Data {
// camera position
cam_pos: vec4<f32>,
};
//group 0 is the camera
@group(0)
@binding(0)
var<uniform> r_data: Data;
var<uniform> camera: Camera;
struct SkyOutput {
@builtin(position) position: vec4<f32>,
@location(0) sampledir: vec3<f32>,
};
@vertex
fn vs_sky(@builtin(vertex_index) vertex_index: u32) -> SkyOutput {
@ -30,8 +32,8 @@ fn vs_sky(@builtin(vertex_index) vertex_index: u32) -> SkyOutput {
);
// transposition = inversion for this orthonormal matrix
let inv_model_view = transpose(mat3x3<f32>(r_data.view[0].xyz, r_data.view[1].xyz, r_data.view[2].xyz));
let unprojected = r_data.proj_inv * pos;
let inv_model_view = transpose(mat3x3<f32>(camera.view[0].xyz, camera.view[1].xyz, camera.view[2].xyz));
let unprojected = camera.proj_inv * pos;
var result: SkyOutput;
result.sampledir = inv_model_view * unprojected.xyz;
@ -39,93 +41,65 @@ fn vs_sky(@builtin(vertex_index) vertex_index: u32) -> SkyOutput {
return result;
}
struct GroundOutput {
@builtin(position) position: vec4<f32>,
@location(4) pos: vec3<f32>,
};
const MAX_ENTITY_INSTANCES=1024;
//group 1 is the model
@group(1)
@binding(0)
var<uniform> entity_transforms: array<mat4x4<f32>,MAX_ENTITY_INSTANCES>;
//var<uniform> entity_texture_transforms: array<mat3x3<f32>,MAX_ENTITY_INSTANCES>;
//my fancy idea is to create a megatexture for each model that includes all the textures each intance will need
//the texture transform then maps the texture coordinates to the location of the specific texture
//how to do no texture?
@group(1)
@binding(1)
var model_texture: texture_2d<f32>;
@group(1)
@binding(2)
var model_sampler: sampler;
@vertex
fn vs_ground(@builtin(vertex_index) vertex_index: u32) -> GroundOutput {
// hacky way to draw two triangles that make a square
let tmp1 = i32(vertex_index)/2-i32(vertex_index)/3;
let tmp2 = i32(vertex_index)&1;
let pos = vec3<f32>(
f32(tmp1) * 2.0 - 1.0,
0.0,
f32(tmp2) * 2.0 - 1.0
) * 160.0;
var result: GroundOutput;
result.pos = pos;
result.position = r_data.proj * r_data.view * vec4<f32>(pos, 1.0);
return result;
}
struct EntityOutput {
struct EntityOutputTexture {
@builtin(position) position: vec4<f32>,
@location(1) texture: vec2<f32>,
@location(2) normal: vec3<f32>,
@location(3) view: vec3<f32>,
};
@group(1)
@binding(0)
var<uniform> r_EntityTransform: mat4x4<f32>;
@vertex
fn vs_entity(
fn vs_entity_texture(
@builtin(instance_index) instance: u32,
@location(0) pos: vec3<f32>,
@location(1) texture: vec2<f32>,
@location(2) normal: vec3<f32>,
) -> EntityOutput {
var position: vec4<f32> = r_EntityTransform * vec4<f32>(pos, 1.0);
var result: EntityOutput;
result.normal = (r_EntityTransform * vec4<f32>(normal, 0.0)).xyz;
result.texture=texture;
result.view = position.xyz - r_data.cam_pos.xyz;
result.position = r_data.proj * r_data.view * position;
) -> EntityOutputTexture {
var position: vec4<f32> = entity_transforms[instance] * vec4<f32>(pos, 1.0);
var result: EntityOutputTexture;
result.normal = (entity_transforms[instance] * vec4<f32>(normal, 0.0)).xyz;
result.texture=texture;//(entity_texture_transforms[instance] * vec3<f32>(texture, 1.0)).xy;
result.view = position.xyz - camera.cam_pos.xyz;
result.position = camera.proj * camera.view * position;
return result;
}
@group(0)
//group 2 is the skybox texture
@group(2)
@binding(0)
var cube_texture: texture_cube<f32>;
@group(2)
@binding(1)
var r_texture: texture_cube<f32>;
@group(0)
@binding(2)
var r_sampler: sampler;
var cube_sampler: sampler;
@fragment
fn fs_sky(vertex: SkyOutput) -> @location(0) vec4<f32> {
return textureSample(r_texture, r_sampler, vertex.sampledir);
return textureSample(cube_texture, model_sampler, vertex.sampledir);
}
@fragment
fn fs_entity(vertex: EntityOutput) -> @location(0) vec4<f32> {
fn fs_entity_texture(vertex: EntityOutputTexture) -> @location(0) vec4<f32> {
let incident = normalize(vertex.view);
let normal = normalize(vertex.normal);
let d = dot(normal, incident);
let reflected = incident - 2.0 * d * normal;
let dir = vec3<f32>(-1.0)+2.0*vec3<f32>(vertex.texture.x,0.0,vertex.texture.y);
let texture_color = textureSample(r_texture, r_sampler, dir).rgb;
let reflected_color = textureSample(r_texture, r_sampler, reflected).rgb;
return vec4<f32>(mix(vec3<f32>(0.1) + 0.5 * reflected_color,texture_color,1.0-pow(1.0-abs(d),2.0)), 1.0);
}
fn modulo_euclidean (a: f32, b: f32) -> f32 {
var m = a % b;
if (m < 0.0) {
if (b < 0.0) {
m -= b;
} else {
m += b;
}
}
return m;
}
@fragment
fn fs_ground(vertex: GroundOutput) -> @location(0) vec4<f32> {
let dir = vec3<f32>(-1.0)+vec3<f32>(modulo_euclidean(vertex.pos.x/16.,1.0),0.0,modulo_euclidean(vertex.pos.z/16.,1.0))*2.0;
return vec4<f32>(textureSample(r_texture, r_sampler, dir).rgb, 1.0);
let fragment_color = textureSample(model_texture, model_sampler, vertex.texture).rgb;
let reflected_color = textureSample(cube_texture, cube_sampler, reflected).rgb;
return vec4<f32>(mix(vec3<f32>(0.1) + 0.5 * reflected_color,fragment_color,1.0-pow(1.0-abs(d),2.0)), 1.0);
}