load roblox map with epic cube code

Cargo.lock

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

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafe-client"
-version = "0.5.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

@@ -12,8 +12,6 @@ pub enum PhysicsInstruction {
 	// 	bool,//true = Trigger; false = teleport
 	// 	bool,//true = Force
 	// )
-	//temp
-	SetPosition(glam::Vec3),
 	//Both of these conditionally activate RefreshWalkTarget (by doing what SetWalkTargetVelocity used to do and then flagging it)
 	Input(InputInstruction),
 }
@@ -256,7 +254,8 @@ pub struct PhysicsState {
 	pub hitbox_halfsize: glam::Vec3,
 	pub contacts: std::collections::HashSet::<RelativeCollision>,
 	//pub intersections: Vec<ModelId>,
-	pub models: Vec<ModelPhysics>,
+	//temp
+	pub models_cringe_clone: Vec<Model>,
 	//camera must exist in state because wormholes modify the camera, also camera punch
 	pub camera: Camera,
 	pub mouse_interpolation: MouseInterpolationState,
@@ -383,13 +382,13 @@ impl Aabb {
 type TreyMeshFace = AabbFace;
 type TreyMesh = Aabb;
 
-pub struct ModelPhysics {
+pub struct Model {
 	//A model is a thing that has a hitbox. can be represented by a list of TreyMesh-es
 	//in this iteration, all it needs is extents.
 	transform: glam::Mat4,
 }
 
-impl ModelPhysics {
+impl Model {
 	pub fn new(transform:glam::Mat4) -> Self {
 		Self{transform}
 	}
@@ -433,10 +432,10 @@ pub struct RelativeCollision {
 }
 
 impl RelativeCollision {
-	pub fn mesh(&self,models:&Vec<ModelPhysics>) -> TreyMesh {
+	pub fn mesh(&self,models:&Vec<Model>) -> TreyMesh {
 		return models.get(self.model as usize).unwrap().face_mesh(self.face)
 	}
-	pub fn normal(&self,models:&Vec<ModelPhysics>) -> glam::Vec3 {
+	pub fn normal(&self,models:&Vec<Model>) -> glam::Vec3 {
 		return models.get(self.model as usize).unwrap().face_normal(self.face)
 	}
 }
@@ -495,7 +494,7 @@ impl PhysicsState {
 
 	fn contact_constrain_velocity(&self,velocity:&mut glam::Vec3){
 		for contact in self.contacts.iter() {
-			let n=contact.normal(&self.models);
+			let n=contact.normal(&self.models_cringe_clone);
 			let d=velocity.dot(n);
 			if d<0f32{
 				(*velocity)-=d/n.length_squared()*n;
@@ -504,7 +503,7 @@ impl PhysicsState {
 	}
 	fn contact_constrain_acceleration(&self,acceleration:&mut glam::Vec3){
 		for contact in self.contacts.iter() {
-			let n=contact.normal(&self.models);
+			let n=contact.normal(&self.models_cringe_clone);
 			let d=acceleration.dot(n);
 			if d<0f32{
 				(*acceleration)-=d/n.length_squared()*n;
@@ -604,7 +603,7 @@ impl PhysicsState {
 		let mut best_time=time_limit;
 		let mut exit_face:Option<TreyMeshFace>=None;
 		let mesh0=self.mesh();
-		let mesh1=self.models.get(collision_data.model as usize).unwrap().mesh();
+		let mesh1=self.models_cringe_clone.get(collision_data.model as usize).unwrap().mesh();
 		let (v,a)=(-self.body.velocity,self.body.acceleration);
 		//collect x
 		match collision_data.face {
@@ -755,7 +754,7 @@ impl PhysicsState {
 		let mut best_time=time_limit;
 		let mut best_face:Option<TreyMeshFace>=None;
 		let mesh0=self.mesh();
-		let mesh1=self.models.get(model_id as usize).unwrap().mesh();
+		let mesh1=self.models_cringe_clone.get(model_id as usize).unwrap().mesh();
 		let (p,v,a)=(self.body.position,self.body.velocity,self.body.acceleration);
 		//collect x
 		for t in zeroes2(mesh0.max.x-mesh1.min.x,v.x,0.5*a.x) {
@@ -880,7 +879,7 @@ impl crate::instruction::InstructionEmitter<PhysicsInstruction> for PhysicsState
 			collector.collect(self.predict_collision_end(self.time,time_limit,collision_data));
 		}
 		//check for collision start instructions (against every part in the game with no optimization!!)
-		for i in 0..self.models.len() {
+		for i in 0..self.models_cringe_clone.len() {
 			collector.collect(self.predict_collision_start(self.time,time_limit,i as u32));
 		}
 		if self.grounded {
@@ -904,7 +903,6 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 		//selectively update body
 		match &ins.instruction {
 		    PhysicsInstruction::Input(InputInstruction::MoveMouse(_)) => (),//dodge time for mouse movement
-		    PhysicsInstruction::SetPosition(_) => self.time=ins.time,//TODO: queue instructions
     		PhysicsInstruction::Input(_)
 		    |PhysicsInstruction::ReachWalkTargetVelocity
 		    |PhysicsInstruction::CollisionStart(_)
@@ -912,15 +910,6 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 		    |PhysicsInstruction::StrafeTick => self.advance_time(ins.time),
 		}
 		match ins.instruction {
-			PhysicsInstruction::SetPosition(position)=>{
-				//temp
-				self.body.position=position;
-				//manual clear //for c in self.contacts{process_instruction(CollisionEnd(c))}
-				self.contacts.clear();
-				self.body.acceleration=self.gravity;
-				self.walk.state=WalkEnum::Reached;
-				self.grounded=false;
-			}
 			PhysicsInstruction::CollisionStart(c) => {
 				//check ground
 				match &c.face {
@@ -1029,4 +1018,4 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 			},
 		}
 	}
-}
+}

src/framework.rs

@@ -51,7 +51,7 @@ pub trait Example: 'static + Sized {
 		device: &wgpu::Device,
 		queue: &wgpu::Queue,
 	);
-	fn update(&mut self, device: &wgpu::Device, event: WindowEvent);
+	fn update(&mut self, event: WindowEvent);
 	fn device_event(&mut self, event: DeviceEvent);
 	fn render(
 		&mut self,
@@ -344,7 +344,7 @@ fn start<E: Example>(
 					println!("{:#?}", instance.generate_report());
 				}
 				_ => {
-					example.update(&device,event);
+					example.update(event);
 				}
 			},
 			event::Event::DeviceEvent {

src/load_roblox.rs

@@ -10,7 +10,8 @@ fn class_is_a(class: &str, superclass: &str) -> bool {
 	}
 	return false
 }
-pub fn get_objects<R: std::io::Read>(buf_thing: R, superclass: &str) -> Result<std::vec::Vec<rbx_dom_weak::Instance>, Box<dyn std::error::Error>> {
+
+pub fn get_objects(buf_thing: std::io::BufReader<&[u8]>, superclass: &str) -> Result<std::vec::Vec<rbx_dom_weak::Instance>, Box<dyn std::error::Error>> {
 	// Using buffered I/O is recommended with rbx_binary
 	let dom = rbx_binary::from_reader(buf_thing)?;
 

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,70 +39,93 @@ fn vs_sky(@builtin(vertex_index) vertex_index: u32) -> SkyOutput {
 	return result;
 }
 
-struct ModelInstance{
-	transform:mat4x4<f32>,
-	//texture_transform:mat3x3<f32>,
-	color:vec4<f32>,
-}
-//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
-//group 1 is the model
-@group(1)
-@binding(0)
-var<storage> model_instances: array<ModelInstance>;
-@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>,
-	@location(4) color: vec4<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>,
-	@location(3) color: vec4<f32>,
-) -> EntityOutputTexture {
-	var position: vec4<f32> = model_instances[instance].transform * vec4<f32>(pos, 1.0);
-	var result: EntityOutputTexture;
-	result.normal = (model_instances[instance].transform * vec4<f32>(normal, 0.0)).xyz;
-	result.texture=texture;//(model_instances[instance].texture_transform * vec3<f32>(texture, 1.0)).xy;
-	result.color=model_instances[instance].color * color;
-	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)*vertex.color;
-	let reflected_color = textureSample(cube_texture, cube_sampler, reflected).rgb;
-	return mix(vec4<f32>(vec3<f32>(0.1) + 0.5 * reflected_color,1.0),fragment_color,1.0-pow(1.0-abs(d),2.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);
 }