project ideal point

This reverts commit 0ddd41c1b6.

engine/graphics/src/graphics.rs

@@ -8,7 +8,17 @@ use wgpu::{util::DeviceExt,AstcBlock,AstcChannel};
 use crate::model::{self as model_graphics,IndexedGraphicsMeshOwnedRenderConfig,IndexedGraphicsMeshOwnedRenderConfigId,GraphicsMeshOwnedRenderConfig,GraphicsModelColor4,GraphicsModelOwned,GraphicsVertex,DebugGraphicsVertex};
 
 pub fn required_limits()->wgpu::Limits{
-	wgpu::Limits::default()
+	let mut limits=wgpu::Limits::default();
+	limits.max_task_invocations_per_dimension=1;
+	limits.max_task_invocations_per_workgroup=1;
+	limits.max_mesh_invocations_per_dimension=1;
+	limits.max_mesh_invocations_per_workgroup=1;
+	limits.max_task_mesh_workgroup_total_count=1;
+	limits.max_task_mesh_workgroups_per_dimension=1;
+	limits.max_task_payload_size=4;
+	limits.max_mesh_output_vertices=2*(3+2+4+8);
+	limits.max_mesh_output_primitives=2*(1+2+4+8)+2;
+	limits
 }
 
 struct Indices{
@@ -38,17 +48,21 @@ struct GraphicsModel{
 
 struct DebugGraphicsSubmesh{
 	verts:Vec<strafesnet_physics::model::MeshVertId>,
-	edges:Vec<Indices>,
+	edges:Vec<[strafesnet_physics::model::MeshVertId;2]>,
 	faces:Vec<Indices>,
 }
 struct DebugGraphicsMesh{
-	verts:Indices,
+	vertices:Vec<DebugGraphicsVertex>,
 	submeshes:Vec<DebugGraphicsSubmesh>,
 	vertex_buf:wgpu::Buffer,
 }
 struct DebugGraphicsModel{
 	debug_mesh_id:u32,
 	bind_group:wgpu::BindGroup,
+	// 32 bytes used to tell the mesh shader where to draw
+	// Vert: [vec4,_]
+	// Edge: [vec4,vec4]
+	debug_buf:wgpu::Buffer,
 }
 
 struct GraphicsSamplers{
@@ -215,7 +229,7 @@ impl GraphicsState{
 			let submeshes=if let Ok(physics_mesh)=strafesnet_physics::model::PhysicsMesh::try_from(mesh){
 				physics_mesh.submesh_views().into_iter().map(|submesh_view|DebugGraphicsSubmesh{
 					verts:submesh_view.verts().to_owned(),
-					edges:submesh_view.edge_vert_ids_iter().map(|edge_verts|indices!(edge_verts)).collect(),
+					edges:submesh_view.edge_vert_ids_iter().collect(),
 					faces:submesh_view.face_vert_ids_iter().map(|face_verts|{
 						// triangulate
 						let mut indices=Vec::new();
@@ -235,7 +249,7 @@ impl GraphicsState{
 			};
 
 			DebugGraphicsMesh{
-				verts:indices!((0..vertices.len() as u32).map(strafesnet_physics::model::MeshVertId::new)),
+				vertices,
 				submeshes,
 				vertex_buf,
 			}
@@ -253,6 +267,11 @@ impl GraphicsState{
 				contents:bytemuck::cast_slice(&model_uniforms),
 				usage:wgpu::BufferUsages::UNIFORM|wgpu::BufferUsages::COPY_DST,
 			});
+			let debug_buf=device.create_buffer_init(&wgpu::util::BufferInitDescriptor{
+				label:Some(format!("Debug Model{} EV Buf",model_id).as_str()),
+				contents:bytemuck::cast_slice(&[0u8;32]),
+				usage:wgpu::BufferUsages::UNIFORM|wgpu::BufferUsages::COPY_DST,
+			});
 			let bind_group=device.create_bind_group(&wgpu::BindGroupDescriptor{
 				layout:&self.bind_group_layouts.debug_model,
 				entries:&[
@@ -260,12 +279,17 @@ impl GraphicsState{
 						binding:0,
 						resource:model_buf.as_entire_binding(),
 					},
+					wgpu::BindGroupEntry{
+						binding:1,
+						resource:debug_buf.as_entire_binding(),
+					},
 				],
 				label:Some(format!("Debug Model{} Bind Group",model_id).as_str()),
 			});
 			DebugGraphicsModel{
 				debug_mesh_id:model.mesh.get(),
 				bind_group,
+				debug_buf,
 			}
 		}).collect();
 
@@ -649,7 +673,7 @@ impl GraphicsState{
 			entries:&[
 				wgpu::BindGroupLayoutEntry{
 					binding:0,
-					visibility:wgpu::ShaderStages::VERTEX,
+					visibility:wgpu::ShaderStages::VERTEX|wgpu::ShaderStages::MESH,
 					ty:wgpu::BindingType::Buffer{
 						ty:wgpu::BufferBindingType::Uniform,
 						has_dynamic_offset:false,
@@ -716,7 +740,17 @@ impl GraphicsState{
 			entries:&[
 				wgpu::BindGroupLayoutEntry{
 					binding:0,
-					visibility:wgpu::ShaderStages::VERTEX_FRAGMENT,
+					visibility:wgpu::ShaderStages::VERTEX_FRAGMENT|wgpu::ShaderStages::MESH,
+					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::MESH,
 					ty:wgpu::BindingType::Buffer{
 						ty:wgpu::BufferBindingType::Uniform,
 						has_dynamic_offset:false,
@@ -880,7 +914,7 @@ impl GraphicsState{
 					&camera_bind_group_layout,
 					&debug_model_bind_group_layout,
 				],
-				push_constant_ranges:&[],
+				immediate_size:0,
 			});
 		let sky_pipeline_layout=device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor{
 			label:None,
@@ -957,12 +991,12 @@ impl GraphicsState{
 			multiview_mask:None,
 			cache:None,
 		});
-		let mut debug_model_pipeline=wgpu::RenderPipelineDescriptor{
-			label:None,
+		let debug_model_pipeline_face=device.create_render_pipeline(&wgpu::RenderPipelineDescriptor{
+			label:Some("Debug Face Pipeline"),
 			layout:Some(&debug_model_pipeline_layout),
 			vertex:wgpu::VertexState{
 				module:&shader,
-				entry_point:Some("vs_debug"),
+				entry_point:Some("vs_debug_face"),
 				buffers:&[wgpu::VertexBufferLayout{
 					array_stride:size_of::<DebugGraphicsVertex>() as wgpu::BufferAddress,
 					step_mode:wgpu::VertexStepMode::Vertex,
@@ -981,6 +1015,7 @@ impl GraphicsState{
 				compilation_options:wgpu::PipelineCompilationOptions::default(),
 			}),
 			primitive:wgpu::PrimitiveState{
+				topology:wgpu::PrimitiveTopology::TriangleList,
 				front_face:wgpu::FrontFace::Cw,
 				cull_mode:Some(wgpu::Face::Front),
 				..Default::default()
@@ -993,18 +1028,55 @@ impl GraphicsState{
 				bias:wgpu::DepthBiasState::default(),
 			}),
 			multisample:wgpu::MultisampleState::default(),
+			multiview_mask:None,
+			cache:None,
+		});
+		let mut debug_model_pipeline=wgpu::MeshPipelineDescriptor{
+			label:None,//filled in below
+			layout:Some(&debug_model_pipeline_layout),
+			task:Some(wgpu::TaskState{
+				module:&shader,
+				entry_point:Some("ts_main"),
+				compilation_options:wgpu::PipelineCompilationOptions::default(),
+			}),
+			mesh:wgpu::MeshState{
+				module:&shader,
+				entry_point:None,//filled in below
+				compilation_options:wgpu::PipelineCompilationOptions::default(),
+			},
+			fragment:Some(wgpu::FragmentState{
+				module:&shader,
+				entry_point:Some("fs_debug"),
+				targets:&[Some(wgpu::ColorTargetState{
+					format:config.view_formats[0],
+					blend:Some(wgpu::BlendState::ALPHA_BLENDING),
+					write_mask:wgpu::ColorWrites::default(),
+				})],
+				compilation_options:wgpu::PipelineCompilationOptions::default(),
+			}),
+			primitive:wgpu::PrimitiveState{
+				topology:wgpu::PrimitiveTopology::TriangleList,
+				front_face:wgpu::FrontFace::Cw,
+				cull_mode:None,
+				..Default::default()
+			},
+			depth_stencil:Some(wgpu::DepthStencilState{
+				format:Self::DEPTH_FORMAT,
+				depth_write_enabled:true,
+				depth_compare:wgpu::CompareFunction::Always,
+				stencil:wgpu::StencilState::default(),
+				bias:wgpu::DepthBiasState::default(),
+			}),
+			multisample:wgpu::MultisampleState::default(),
 			multiview:None,
 			cache:None,
 		};
-		debug_model_pipeline.label=Some("Debug Face Pipeline");
-		debug_model_pipeline.primitive.topology=wgpu::PrimitiveTopology::TriangleList;
-		let debug_model_pipeline_face=device.create_render_pipeline(&debug_model_pipeline);
-		debug_model_pipeline.label=Some("Debug Edge Pipeline");
-		debug_model_pipeline.primitive.topology=wgpu::PrimitiveTopology::LineList;
-		let debug_model_pipeline_edge=device.create_render_pipeline(&debug_model_pipeline);
 		debug_model_pipeline.label=Some("Debug Vert Pipeline");
-		debug_model_pipeline.primitive.topology=wgpu::PrimitiveTopology::PointList;
-		let debug_model_pipeline_vert=device.create_render_pipeline(&debug_model_pipeline);
+		debug_model_pipeline.mesh.entry_point=Some("ms_debug_vert");
+		let debug_model_pipeline_vert=device.create_mesh_pipeline(&debug_model_pipeline);
+		debug_model_pipeline.label=Some("Debug Edge Pipeline");
+		debug_model_pipeline.mesh.entry_point=Some("ms_debug_edge");
+		let debug_model_pipeline_edge=device.create_mesh_pipeline(&debug_model_pipeline);
 
 		let camera=GraphicsCamera::default();
 		let camera_uniforms=camera.to_uniform_data(glam::Vec3::ZERO,glam::Vec2::ZERO);
@@ -1117,6 +1189,49 @@ impl GraphicsState{
 				.copy_from_slice(bytemuck::cast_slice(&model_uniforms));
 		}
 		*/
+		// upload the edge or vertex for teh mesh shader to highlight
+		if let Some(hit)=&frame_state.hit{
+			if let Some(closest_fev)=&hit.closest_fev{
+				let model_id:model::ModelId=hit.convex_mesh_id.model_id.into();
+				if let Some(model)=self.debug_models.get(model_id.get() as usize){
+					let mesh=&self.debug_meshes[model.debug_mesh_id as usize];
+					match closest_fev{
+						strafesnet_physics::model::FEV::Face(_face)=>{
+							// face is rendered normally
+						},
+						strafesnet_physics::model::FEV::Edge(edge)=>{
+							let [v0_id,v1_id]=mesh.submeshes[hit.convex_mesh_id.submesh_id.get() as usize].edges[edge.get() as usize];
+							let v0_pos=mesh.vertices[v0_id.get() as usize].pos;
+							let v1_pos=mesh.vertices[v1_id.get() as usize].pos;
+							let debug_data=[glam::Vec3A::from_array(v0_pos).extend(1.0).to_array(),glam::Vec3A::from_array(v1_pos).extend(1.0).to_array()];
+							let debug_slice=bytemuck::cast_slice(&debug_data);
+							self.staging_belt
+								.write_buffer(
+									&mut encoder,
+									&model.debug_buf,
+									0,
+									wgpu::BufferSize::new(debug_slice.len() as wgpu::BufferAddress).unwrap(),
+								)
+								.copy_from_slice(debug_slice);
+						},
+						strafesnet_physics::model::FEV::Vert(vert)=>{
+							let vert_id=mesh.submeshes[hit.convex_mesh_id.submesh_id.get() as usize].verts[vert.get() as usize].get();
+							let pos=mesh.vertices[vert_id as usize].pos;
+							let debug_data=[glam::Vec3A::from_array(pos).extend(1.0).to_array()];
+							let debug_slice=bytemuck::cast_slice(&debug_data);
+							self.staging_belt
+								.write_buffer(
+									&mut encoder,
+									&model.debug_buf,
+									0,
+									wgpu::BufferSize::new(debug_slice.len() as wgpu::BufferAddress).unwrap(),
+								)
+								.copy_from_slice(debug_slice);
+						},
+					}
+				}
+			}
+		}
 		self.staging_belt.finish();
 
 		{
@@ -1166,7 +1281,7 @@ impl GraphicsState{
 			rpass.draw(0..3,0..1);
 
 			// render a single debug_model in red
-			if let Some(hit)=frame_state.hit{
+			if let Some(hit)=&frame_state.hit{
 				if let Some(closest_fev)=&hit.closest_fev{
 					let model_id:model::ModelId=hit.convex_mesh_id.model_id.into();
 					if let Some(model)=self.debug_models.get(model_id.get() as usize){
@@ -1181,18 +1296,15 @@ impl GraphicsState{
 								//TODO: loop over triangle strips
 								rpass.draw_indexed(0..indices.count,0,0..1);
 							},
-							strafesnet_physics::model::FEV::Edge(edge)=>{
+							strafesnet_physics::model::FEV::Edge(_edge)=>{
 								rpass.set_pipeline(&self.pipelines.debug_edge);
-								let indices=&mesh.submeshes[hit.convex_mesh_id.submesh_id.get() as usize].edges[edge.get() as usize];
-								rpass.set_index_buffer(indices.buf.slice(..),indices.format);
-								rpass.draw_indexed(0..indices.count,0,0..1);
+								// the data has already been primed by the staging belt
+								rpass.draw_mesh_tasks(1, 1, 1);
 							},
-							strafesnet_physics::model::FEV::Vert(vert)=>{
+							strafesnet_physics::model::FEV::Vert(_vert)=>{
 								rpass.set_pipeline(&self.pipelines.debug_vert);
-								let indices=&mesh.verts;
-								rpass.set_index_buffer(indices.buf.slice(..),indices.format);
-								let vert_id=mesh.submeshes[hit.convex_mesh_id.submesh_id.get() as usize].verts[vert.get() as usize].get();
-								rpass.draw_indexed(0..1,vert_id as i32,0..1);
+								// the data has already been primed by the staging belt
+								rpass.draw_mesh_tasks(1, 1, 1);
 							},
 						}
 					}

strafe-client/src/graphics_worker.rs

@@ -34,8 +34,8 @@ pub fn new(
 			Instruction::Resize(size,user_settings)=>{
 				println!("Resizing to {:?}",size);
 				let t0=std::time::Instant::now();
-				config.width=640;
-				config.height=480;
+				config.width=size.width.max(1);
+				config.height=size.height.max(1);
 				surface.configure(&device,&config);
 				graphics.resize(&device,&config,&user_settings);
 				println!("Resize took {:?}",t0.elapsed());

strafe-client/src/setup.rs

@@ -3,7 +3,7 @@ fn optional_features()->wgpu::Features{
 	|wgpu::Features::TEXTURE_COMPRESSION_ETC2
 }
 fn required_features()->wgpu::Features{
-	wgpu::Features::TEXTURE_COMPRESSION_BC
+	wgpu::Features::TEXTURE_COMPRESSION_BC|wgpu::Features::EXPERIMENTAL_MESH_SHADER
 }
 fn required_downlevel_capabilities()->wgpu::DownlevelCapabilities{
 	wgpu::DownlevelCapabilities{
@@ -125,7 +125,7 @@ impl<'a> SetupContextPartial3<'a>{
 					required_limits:needed_limits,
 					memory_hints:wgpu::MemoryHints::Performance,
 					trace:wgpu::Trace::Off,
-					experimental_features:wgpu::ExperimentalFeatures::disabled(),
+					experimental_features:unsafe{wgpu::ExperimentalFeatures::enabled()},
 				},
 			))
 			.expect("Unable to find a suitable GPU adapter!");

strafe-client/src/shader.wgsl

@@ -1,3 +1,5 @@
+enable wgpu_mesh_shader;
+
 struct Camera {
 	// from camera to screen
 	proj: mat4x4<f32>,
@@ -90,23 +92,162 @@ fn vs_entity_texture(
 @binding(0)
 var<uniform> model_instance: ModelInstance;
 
+@group(1)
+@binding(1)
+var<uniform> ve_verts: array<vec4<f32>, 2>;
+
 struct DebugEntityOutput {
 	@builtin(position) position: vec4<f32>,
-	@location(1) normal: vec3<f32>,
-	@location(2) view: vec3<f32>,
 };
 
 @vertex
-fn vs_debug(
+fn vs_debug_face(
 	@location(0) pos: vec3<f32>,
 ) -> DebugEntityOutput {
 	var position: vec4<f32> = model_instance.transform * vec4<f32>(pos, 1.0);
 	var result: DebugEntityOutput;
-	result.view = position.xyz - camera.view_inv[3].xyz;//col(3)
 	result.position = camera.proj * camera.view * position;
 	return result;
 }
 
+struct TaskPayload {
+    four_bytes: u32,
+}
+
+var<task_payload> taskPayload: TaskPayload;
+
+@task
+@payload(taskPayload)
+@workgroup_size(1)
+fn ts_main() -> @builtin(mesh_task_size) vec3<u32> {
+	taskPayload.four_bytes = 0;
+	return vec3(1, 1, 1);
+}
+
+struct VertexOutput {
+	@builtin(position) position: vec4<f32>,
+	@location(0) color: vec4<f32>,
+}
+struct PrimitiveOutput {
+	@builtin(triangle_indices) indices: vec3<u32>,
+}
+
+struct CircleOutput {
+	@builtin(vertices) vertices: array<VertexOutput, 24>,
+	@builtin(primitives) primitives: array<PrimitiveOutput, 22>,
+	@builtin(vertex_count) vertex_count: u32,
+	@builtin(primitive_count) primitive_count: u32,
+}
+
+var<workgroup> mesh_output: CircleOutput;
+
+const tau: f32 = 3.141592653589793 * 2.0;
+
+fn modulo(value:u32,modulus:u32)->u32{
+	return value-value/modulus*modulus;
+}
+
+@mesh(mesh_output)
+@payload(taskPayload)
+@workgroup_size(1)
+fn ms_debug_vert(){
+	// circle with 24 vertices.
+	const LAYERS:u32 = 3;
+	const N:u32 = 3*(1<<LAYERS);
+	mesh_output.vertex_count = N;
+	mesh_output.primitive_count = N-2;
+
+	var vertex_world_position: vec4<f32> = model_instance.transform * ve_verts[0];
+	var vertex_screen_position: vec4<f32> = camera.proj * camera.view * vertex_world_position;
+
+	for (var i:u32 = 0; i<N/4; i++){
+		// draw a 1 unit redius circle
+		var theta: f32 = f32(i) * tau / f32(N);
+		var cos_sin: vec2<f32> = vec2(cos(theta), sin(theta));
+		var offset: vec2<f32> = 0.5 * cos_sin;
+		mesh_output.vertices[i].position = vertex_screen_position + vec4<f32>(offset, 0.0, 0.0);
+		mesh_output.vertices[i+N/4].position = vertex_screen_position + vec4<f32>(-offset.y, offset.x, 0.0, 0.0);
+		mesh_output.vertices[i+N/4*2].position = vertex_screen_position + vec4<f32>(-offset, 0.0, 0.0);
+		mesh_output.vertices[i+N/4*3].position = vertex_screen_position + vec4<f32>(offset.y, -offset.x, 0.0, 0.0);
+	}
+
+	// max area triangle indices
+
+	// the big triangle
+	mesh_output.primitives[0].indices = vec3<u32>(0, N/3, N/3*2);
+
+	// 3 layers of infill triangles to approximate circle better than 1 triangle.
+	// we start on the outer layer because it's easier to construct this way
+	var count:u32=N;
+	var base:u32=1;
+	for (var layer:u32 = 0; layer<LAYERS; layer++){
+		count=count>>1;
+		var step:u32=N/count;
+		for (var i:u32 = 0; i<count; i++){
+			mesh_output.primitives[base+i].indices = vec3<u32>(i*step, i*step+(step>>1), modulo(i*step+step,N));
+		}
+		base+=count;
+	}
+}
+
+@mesh(mesh_output)
+@payload(taskPayload)
+@workgroup_size(1)
+fn ms_debug_edge(){
+	// draw two circles for now.
+	const LAYERS:u32 = 3;
+	const N:u32 = 2*(1<<LAYERS);
+	mesh_output.vertex_count = 2*(3+2+4+8);
+	mesh_output.primitive_count = 2*(1+2+4+8)+2;
+
+	var v0_world_position: vec4<f32> = model_instance.transform * ve_verts[0];
+	var v1_world_position: vec4<f32> = model_instance.transform * ve_verts[1];
+
+	var v0_screen_position: vec4<f32> = camera.proj * camera.view * v0_world_position;
+	var v1_screen_position: vec4<f32> = camera.proj * camera.view * v1_world_position;
+
+	var edge_dir_world: vec4<f32> = normalize(v0_world_position - v1_world_position);
+	var edge_dir_screen: vec4<f32> = camera.proj * camera.view * edge_dir_world;
+
+	for (var i:u32 = 0; i<=N/2; i++){
+		// two half circles that make a whole
+		var theta: f32 = f32(i) * tau / f32(N);
+		var cos_sin: vec2<f32> = vec2(cos(theta), sin(theta));
+
+		// construct basis vectors
+		var y_axis: vec2<f32> = edge_dir_screen.xy;
+		var x_axis: vec2<f32> = y_axis.yx;
+		x_axis.x = -x_axis.x;
+
+		var offset: vec4<f32> = vec4<f32>(0.5 * (x_axis * cos_sin.x + y_axis * cos_sin.y), 0.0, 0.0);;
+
+		mesh_output.vertices[i].position = v0_screen_position + offset;
+		mesh_output.vertices[N/2+1+i].position = v1_screen_position - offset;
+	}
+
+	// max area triangle indices
+	// number of primitives per circle half
+	const P:u32 = N/2;
+	// the big triangles between the circles
+	mesh_output.primitives[0].indices = vec3<u32>(0, N/2+1, P);
+	mesh_output.primitives[P].indices = vec3<u32>(N/2+1, 0, P + N/2+1);
+
+	// 3 layers of infill triangles to approximate circle better than 1 triangle.
+	// we start on the outer layer because it's easier to construct this way
+	var count:u32=P;
+	var base:u32=1;
+	for (var layer:u32 = 0; layer<LAYERS; layer++){
+		count=count>>1;
+		var step:u32=P/count;
+		for (var i:u32 = 0; i<count; i++){
+			var indices = vec3<u32>(i*step, i*step+(step>>1), i*step+step);
+			mesh_output.primitives[base+i].indices = indices;
+			mesh_output.primitives[P+base+i].indices = indices + N/2+1;
+		}
+		base+=count;
+	}
+}
+
 //group 2 is the skybox texture
 @group(1)
 @binding(0)