TEMP: fix menacing circle strafing

Cargo.lock

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

Cargo.toml

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

src/body.rs

@@ -102,7 +102,7 @@ pub struct MouseInterpolationState {
 impl MouseInterpolationState {
 	pub fn new() -> Self {
 		Self {
-			interpolation:MouseInterpolation::First,
+			interpolation:MouseInterpolation::Lerp,
 			time0:0,
 			time1:1,//ONE NANOSECOND!!!! avoid divide by zero
 			mouse0:glam::IVec2::ZERO,
@@ -122,9 +122,9 @@ impl MouseInterpolationState {
 				let m0=self.mouse0.as_i64vec2();
 				let m1=self.mouse1.as_i64vec2();
 				//these are deltas
-				let t1t=(self.time1-time) as i64;
-				let tt0=(time-self.time0) as i64;
 				let dt=(self.time1-self.time0) as i64;
+				let t1t=(self.time1-time).clamp(0,dt) as i64;
+				let tt0=(time-self.time0).clamp(0,dt) as i64;
 				((m0*t1t+m1*tt0)/dt).as_ivec2()
 			}
 		}
@@ -902,7 +902,6 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 		}
 		//selectively update body
 		match &ins.instruction {
-		    PhysicsInstruction::Input(InputInstruction::MoveMouse(_)) => (),//dodge time for mouse movement
     		PhysicsInstruction::Input(_)
 		    |PhysicsInstruction::ReachWalkTargetVelocity
 		    |PhysicsInstruction::CollisionStart(_)

src/main.rs

@@ -18,42 +18,38 @@ struct Entity {
 	index_buf: wgpu::Buffer,
 }
 
+//temp?
 struct ModelData {
-	transforms: Vec<glam::Mat4>,
-	vertices: Vec<Vertex>,
-	entities: Vec<Vec<u16>>,
+	transform: glam::Mat4,
+	vertex_buf: wgpu::Buffer,
+	entities: Vec<Entity>,
 }
 
 struct ModelGraphics {
-	transforms: Vec<glam::Mat4>,
+	transform: glam::Mat4,
 	vertex_buf: wgpu::Buffer,
 	entities: Vec<Entity>,
 	bind_group: wgpu::BindGroup,
 	model_buf: wgpu::Buffer,
 }
-pub struct GraphicsBindGroups {
-	camera: wgpu::BindGroup,
-	skybox_texture: wgpu::BindGroup,
-}
 
-pub struct GraphicsPipelines {
-	skybox: wgpu::RenderPipeline,
-	model: wgpu::RenderPipeline,
-}
-
-pub struct GraphicsData {
+pub struct Skybox {
+	block_mouse:strafe_client::body::TIME,
+	period:strafe_client::body::TIME,
 	start_time: std::time::Instant,
 	screen_size: (u32, u32),
 	physics: strafe_client::body::PhysicsState,
-	pipelines: GraphicsPipelines,
-	bind_groups: GraphicsBindGroups,
+	sky_pipeline: wgpu::RenderPipeline,
+	entity_pipeline: wgpu::RenderPipeline,
+	ground_pipeline: wgpu::RenderPipeline,
+	main_bind_group: wgpu::BindGroup,
 	camera_buf: wgpu::Buffer,
 	models: Vec<ModelGraphics>,
 	depth_view: wgpu::TextureView,
 	staging_belt: wgpu::util::StagingBelt,
 }
 
-impl GraphicsData {
+impl Skybox {
 	const DEPTH_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Depth24Plus;
 
 	fn create_depth_texture(
@@ -79,24 +75,18 @@ impl GraphicsData {
 	}
 }
 
-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);
-	}
+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)[..]);
 	raw
 }
 
-fn generate_modeldatas(data:obj::ObjData) -> Vec<ModelData>{
-	let mut modeldatas=Vec::new();
+fn add_obj(device:&wgpu::Device,modeldatas:& mut Vec<ModelData>,source:&[u8]){
+	let data = obj::ObjData::load_buf(&source[..]).unwrap();
 	let mut vertices = Vec::new();
 	let mut vertex_index = std::collections::HashMap::<obj::IndexTuple,u16>::new();
 	for object in data.objects {
-		vertices.clear();
-		vertex_index.clear();
-		let mut entities = Vec::new();
+		let mut entities = Vec::<Entity>::new();
 		for group in object.groups {
 			let mut indices = Vec::new();
 			for poly in group.polys {
@@ -118,15 +108,27 @@ fn generate_modeldatas(data:obj::ObjData) -> Vec<ModelData>{
 					}
 				}
 			}
-			entities.push(indices);
+			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,
+			});
 		}
-		modeldatas.push(ModelData {
-			transforms: vec![],
-			vertices:vertices.clone(),
-			entities,
+		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,
+			entities,
+		})
 	}
-	modeldatas
 }
 
 
@@ -144,7 +146,7 @@ fn to_uniform_data(camera: &strafe_client::body::Camera, pos: glam::Vec3) -> [f3
 	raw
 }
 
-impl strafe_client::framework::Example for GraphicsData {
+impl strafe_client::framework::Example for Skybox {
 	fn optional_features() -> wgpu::Features {
 		wgpu::Features::TEXTURE_COMPRESSION_ASTC
 			| wgpu::Features::TEXTURE_COMPRESSION_ETC2
@@ -157,41 +159,46 @@ impl strafe_client::framework::Example for GraphicsData {
 		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();
-		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));
+		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"));
 		println!("models.len = {:?}", modeldatas.len());
-		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)));
+		modeldatas[1].transform=glam::Mat4::from_translation(glam::vec3(10.,5.,10.));
+		modeldatas[2].transform=glam::Mat4::from_translation(glam::vec3(-10.,5.,10.));
 
-		let camera_bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+		let main_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,
+				},
+				wgpu::BindGroupLayoutEntry {
+					binding: 1,
+					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: 2,
+					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: None,
 			entries: &[
 				wgpu::BindGroupLayoutEntry {
@@ -206,79 +213,6 @@ impl strafe_client::framework::Example for GraphicsData {
 				},
 			],
 		});
-		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,
-					visibility: wgpu::ShaderStages::VERTEX,
-					ty: wgpu::BindingType::Buffer {
-						ty: wgpu::BufferBindingType::Uniform,
-						has_dynamic_offset: false,
-						min_binding_size: None,
-					},
-					count: None,
-				},
-				wgpu::BindGroupLayoutEntry {
-					binding: 1,
-					visibility: wgpu::ShaderStages::FRAGMENT,
-					ty: wgpu::BindingType::Texture {
-						sample_type: wgpu::TextureSampleType::Float { filterable: true },
-						multisampled: false,
-						view_dimension: wgpu::TextureViewDimension::D2,
-					},
-					count: None,
-				},
-				wgpu::BindGroupLayoutEntry {
-					binding: 2,
-					visibility: wgpu::ShaderStages::FRAGMENT,
-					ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
-					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
 		let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
@@ -299,7 +233,7 @@ impl strafe_client::framework::Example for GraphicsData {
 			grounded: false,
 			walkspeed: 18.0,
 			contacts: std::collections::HashSet::new(),
-			models_cringe_clone: modeldatas.iter().map(|m|m.transforms.iter().map(|t|strafe_client::body::Model::new(*t))).flatten().collect(),
+			models_cringe_clone: modeldatas.iter().map(|m|strafe_client::body::Model::new(m.transform)).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)),
@@ -307,126 +241,17 @@ impl strafe_client::framework::Example for GraphicsData {
 			controls: 0,
 		};
 
-		//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()
-			})
-		};
+		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,
+		});
 
 		//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.transforms);
+			let model_uniforms = get_transform_uniform_data(&modeldata.transform);
 			let model_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
 				label: Some(format!("ModelGraphics{}",i).as_str()),
 				contents: bytemuck::cast_slice(&model_uniforms),
@@ -439,37 +264,14 @@ impl strafe_client::framework::Example for GraphicsData {
 						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{
-				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(),
+				transform: modeldata.transform,
+				vertex_buf:modeldata.vertex_buf,
+				entities: modeldata.entities,
 				bind_group: model_bind_group,
 				model_buf,
 			})
@@ -477,17 +279,13 @@ impl strafe_client::framework::Example for GraphicsData {
 
 		let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
 			label: None,
-			bind_group_layouts: &[
-				&camera_bind_group_layout,
-				&model_bind_group_layout,
-				&skybox_texture_bind_group_layout,
-			],
+			bind_group_layouts: &[&main_bind_group_layout, &model_bind_group_layout],
 			push_constant_ranges: &[],
 		});
 
 		// Create the render pipelines
 		let sky_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-			label: Some("Sky Pipeline"),
+			label: Some("Sky"),
 			layout: Some(&pipeline_layout),
 			vertex: wgpu::VertexState {
 				module: &shader,
@@ -513,12 +311,12 @@ impl strafe_client::framework::Example for GraphicsData {
 			multisample: wgpu::MultisampleState::default(),
 			multiview: None,
 		});
-		let model_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-			label: Some("Model Pipeline"),
+		let entity_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+			label: Some("Entity"),
 			layout: Some(&pipeline_layout),
 			vertex: wgpu::VertexState {
 				module: &shader,
-				entry_point: "vs_entity_texture",
+				entry_point: "vs_entity",
 				buffers: &[wgpu::VertexBufferLayout {
 					array_stride: std::mem::size_of::<Vertex>() as wgpu::BufferAddress,
 					step_mode: wgpu::VertexStepMode::Vertex,
@@ -527,7 +325,34 @@ impl strafe_client::framework::Example for GraphicsData {
 			},
 			fragment: Some(wgpu::FragmentState {
 				module: &shader,
-				entry_point: "fs_entity_texture",
+				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",
 				targets: &[Some(config.view_formats[0].into())],
 			}),
 			primitive: wgpu::PrimitiveState {
@@ -545,51 +370,120 @@ impl strafe_client::framework::Example for GraphicsData {
 			multiview: None,
 		});
 
-		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 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_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-			layout: &camera_bind_group_layout,
+
+		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,
 			entries: &[
 				wgpu::BindGroupEntry {
 					binding: 0,
 					resource: camera_buf.as_entire_binding(),
 				},
-			],
-			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),
+					resource: wgpu::BindingResource::TextureView(&texture_view),
+				},
+				wgpu::BindGroupEntry {
+					binding: 2,
+					resource: wgpu::BindingResource::Sampler(&sampler),
 				},
 			],
-			label: Some("Sky Texture"),
+			label: Some("Camera"),
 		});
 
 		let depth_view = Self::create_depth_texture(config, device);
 
-		GraphicsData {
+		Skybox {
+			block_mouse:0,
+			period:5_000_000,
 			start_time: Instant::now(),
 			screen_size: (config.width,config.height),
 			physics,
-			pipelines:GraphicsPipelines{
-				skybox:sky_pipeline,
-				model:model_pipeline
-			},
-			bind_groups:GraphicsBindGroups{
-				camera:camera_bind_group,
-				skybox_texture:skybox_texture_bind_group,
-			},
+			sky_pipeline,
+			entity_pipeline,
+			ground_pipeline,
+			main_bind_group,
 			camera_buf,
 			models,
 			depth_view,
@@ -628,7 +522,7 @@ impl strafe_client::framework::Example for GraphicsData {
 					_ => None,
 				}
 				{
-					self.physics.run(time);
+					self.physics.run(time);//call it a day
 					self.physics.process_instruction(TimedInstruction{
 						time,
 						instruction:PhysicsInstruction::Input(input_instruction),
@@ -638,20 +532,34 @@ impl strafe_client::framework::Example for GraphicsData {
 			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))),
-				})
+				let run_the_physics=
+				if time<self.block_mouse{
+					false
+				}else{
+					if time-self.block_mouse<2*self.period{
+						self.block_mouse+=self.period
+					}else{
+						self.block_mouse=time+self.period
+					}
+					true
+				};
+				if run_the_physics{
+					//This lags like crazy if you require a substep for every mouse event (every 3ms)
+					//I'm going to forgo mouse interpolation for now
+					//because it's actually a hard problem to prevent the physics from running on every mouse update
+					self.physics.run(time);//call it a day
+					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.run(time);//call it a day
 					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
@@ -700,7 +608,7 @@ impl strafe_client::framework::Example for GraphicsData {
 			.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.transforms);
+			let model_uniforms = get_transform_uniform_data(&model.transform);
 			self.staging_belt
 				.write_buffer(
 					&mut encoder,
@@ -739,21 +647,25 @@ impl strafe_client::framework::Example for GraphicsData {
 				}),
 			});
 
-			rpass.set_bind_group(0, &self.bind_groups.camera, &[]);
-			rpass.set_bind_group(2, &self.bind_groups.skybox_texture, &[]);
+			rpass.set_bind_group(0, &self.main_bind_group, &[]);
 
-			rpass.set_pipeline(&self.pipelines.model);
+			rpass.set_pipeline(&self.entity_pipeline);
 			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..model.transforms.len() as u32);
+					rpass.draw_indexed(0..entity.index_count, 0, 0..1);
 				}
 			}
 
-			rpass.set_pipeline(&self.pipelines.skybox);
+			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.draw(0..3, 0..1);
 		}
 
@@ -764,7 +676,7 @@ impl strafe_client::framework::Example for GraphicsData {
 }
 
 fn main() {
-	strafe_client::framework::run::<GraphicsData>(
+	strafe_client::framework::run::<Skybox>(
 		format!("Strafe Client v{}",
 			env!("CARGO_PKG_VERSION")
 		).as_str()

src/shader.wgsl

@@ -1,4 +1,9 @@
-struct Camera {
+struct SkyOutput {
+	@builtin(position) position: vec4<f32>,
+	@location(0) sampledir: vec3<f32>,
+};
+
+struct Data {
 	// from camera to screen
 	proj: mat4x4<f32>,
 	// from screen to camera
@@ -8,16 +13,9 @@ struct Camera {
 	// camera position
 	cam_pos: vec4<f32>,
 };
-
-//group 0 is the camera
 @group(0)
 @binding(0)
-var<uniform> camera: Camera;
-
-struct SkyOutput {
-	@builtin(position) position: vec4<f32>,
-	@location(0) sampledir: vec3<f32>,
-};
+var<uniform> r_data: Data;
 
 @vertex
 fn vs_sky(@builtin(vertex_index) vertex_index: u32) -> SkyOutput {
@@ -32,8 +30,8 @@ fn vs_sky(@builtin(vertex_index) vertex_index: u32) -> SkyOutput {
 	);
 
 	// transposition = inversion for this orthonormal matrix
-	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;
+	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;
 
 	var result: SkyOutput;
 	result.sampledir = inv_model_view * unprojected.xyz;
@@ -41,65 +39,93 @@ fn vs_sky(@builtin(vertex_index) vertex_index: u32) -> SkyOutput {
 	return result;
 }
 
-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;
+struct GroundOutput {
+	@builtin(position) position: vec4<f32>,
+	@location(4) pos: vec3<f32>,
+};
 
-struct EntityOutputTexture {
+@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 {
 	@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_texture(
-	@builtin(instance_index) instance: u32,
+fn vs_entity(
 	@location(0) pos: vec3<f32>,
 	@location(1) texture: vec2<f32>,
 	@location(2) normal: vec3<f32>,
-) -> 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;
+) -> 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;
 	return result;
 }
 
-//group 2 is the skybox texture
-@group(2)
-@binding(0)
-var cube_texture: texture_cube<f32>;
-@group(2)
+@group(0)
 @binding(1)
-var cube_sampler: sampler;
+var r_texture: texture_cube<f32>;
+@group(0)
+@binding(2)
+var r_sampler: sampler;
 
 @fragment
 fn fs_sky(vertex: SkyOutput) -> @location(0) vec4<f32> {
-	return textureSample(cube_texture, model_sampler, vertex.sampledir);
+	return textureSample(r_texture, r_sampler, vertex.sampledir);
 }
 
 @fragment
-fn fs_entity_texture(vertex: EntityOutputTexture) -> @location(0) vec4<f32> {
+fn fs_entity(vertex: EntityOutput) -> @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 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);
+	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);
 }