load roblox map with epic cube code

Cargo.lock

@@ -1645,7 +1645,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/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,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);
 }