load roblox map with epic cube code

.gitignore

@@ -1,2 +1 @@
 /target
-/textures

Cargo.lock

@@ -1442,20 +1442,6 @@ dependencies = [
  "thiserror",
 ]
 
-[[package]]
-name = "rbx_xml"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bc65b70827519fdc4ab47416d1085b912f087fadab9ed415471b6daba635574"
-dependencies = [
- "base64",
- "log",
- "rbx_dom_weak",
- "rbx_reflection",
- "rbx_reflection_database",
- "xml-rs",
-]
-
 [[package]]
 name = "redox_syscall"
 version = "0.3.5"
@@ -1467,9 +1453,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.9.5"
+version = "1.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "697061221ea1b4a94a624f67d0ae2bfe4e22b8a17b6a192afb11046542cc8c47"
+checksum = "12de2eff854e5fa4b1295edd650e227e9d8fb0c9e90b12e7f36d6a6811791a29"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -1479,9 +1465,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.3.8"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2f401f4955220693b56f8ec66ee9c78abffd8d1c4f23dc41a23839eb88f0795"
+checksum = "49530408a136e16e5b486e883fbb6ba058e8e4e8ae6621a77b048b314336e629"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -1659,7 +1645,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "strafe-client"
-version = "0.5.0"
+version = "0.3.0"
 dependencies = [
  "async-executor",
  "bytemuck",
@@ -1672,8 +1658,6 @@ dependencies = [
  "rbx_binary",
  "rbx_dom_weak",
  "rbx_reflection_database",
- "rbx_xml",
- "regex",
  "wgpu",
  "winit",
 ]

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
@@ -17,8 +17,6 @@ pollster = "0.3.0"
 rbx_binary = "0.7.1"
 rbx_dom_weak = "2.5.0"
 rbx_reflection_database = "0.2.7"
-rbx_xml = "0.13.1"
-regex = "1.9.5"
 wgpu = "0.17.0"
 winit = "0.28.6"
 

src/body.rs

@@ -16,8 +16,6 @@ pub enum PhysicsInstruction {
 	// 	bool,//true = Trigger; false = teleport
 	// 	bool,//true = Force
 	// )
-	//temp
-	SetPosition(glam::Vec3),
 }
 
 pub struct Body {
@@ -137,8 +135,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>,
 	pub temp_control_dir: glam::Vec3,
 	//camera must exist in state because wormholes modify the camera, also camera punch
 	//pub camera: Camera,
@@ -266,13 +264,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}
 	}
@@ -316,10 +314,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)
 	}
 }
@@ -370,7 +368,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;
@@ -379,7 +377,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;
@@ -459,7 +457,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 {
@@ -610,7 +608,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) {
@@ -735,7 +733,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 {
@@ -758,7 +756,6 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 		//selectively update body
 		match &ins.instruction {
 		    PhysicsInstruction::SetWalkTargetVelocity(_)
-		    |PhysicsInstruction::SetPosition(_)
 		    |PhysicsInstruction::SetControlDir(_) => self.time=ins.time,//TODO: queue instructions
 		    PhysicsInstruction::RefreshWalkTarget
 		    |PhysicsInstruction::ReachWalkTargetVelocity
@@ -768,15 +765,6 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 		    |PhysicsInstruction::Jump => 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 {
@@ -866,4 +854,4 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 			},
 		}
 	}
-}
+}

src/framework.rs

@@ -53,7 +53,7 @@ pub trait Example: 'static + Sized {
 		device: &wgpu::Device,
 		queue: &wgpu::Queue,
 	);
-	fn update(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, event: WindowEvent);
+	fn update(&mut self, event: WindowEvent);
 	fn move_mouse(&mut self, delta: (f64,f64));
 	fn render(
 		&mut self,
@@ -181,41 +181,9 @@ async fn setup<E: Example>(title: &str) -> Setup {
 
 		(size, surface)
 	};
-
-	let adapter;
-
-	let optional_features = E::optional_features();
-	let required_features = E::required_features();
-
-	//no helper function smh gotta write it myself
-	let adapters = instance.enumerate_adapters(backends);
-
-	let mut chosen_adapter = None;
-	let mut chosen_adapter_score=0;
-	for adapter in adapters {
-		if !adapter.is_surface_supported(&surface) {
-			continue;
-		}
-
-		let score=match adapter.get_info().device_type{
-			wgpu::DeviceType::IntegratedGpu=>3,
-			wgpu::DeviceType::DiscreteGpu=>4,
-			wgpu::DeviceType::VirtualGpu=>2,
-			wgpu::DeviceType::Other|wgpu::DeviceType::Cpu=>1,
-		};
-
-		let adapter_features = adapter.features();
-		if chosen_adapter_score<score&&adapter_features.contains(required_features) {
-			chosen_adapter_score=score;
-			chosen_adapter=Some(adapter);
-		}
-	}
-
-	if let Some(maybe_chosen_adapter) = chosen_adapter{
-		adapter=maybe_chosen_adapter;
-	}else{
-		panic!("No suitable GPU adapters found on the system!");
-	}
+	let adapter = wgpu::util::initialize_adapter_from_env_or_default(&instance, Some(&surface))
+		.await
+		.expect("No suitable GPU adapters found on the system!");
 
 	#[cfg(not(target_arch = "wasm32"))]
 	{
@@ -223,6 +191,15 @@ async fn setup<E: Example>(title: &str) -> Setup {
 		println!("Using {} ({:?})", adapter_info.name, adapter_info.backend);
 	}
 
+	let optional_features = E::optional_features();
+	let required_features = E::required_features();
+	let adapter_features = adapter.features();
+	assert!(
+		adapter_features.contains(required_features),
+		"Adapter does not support required features for this example: {:?}",
+		required_features - adapter_features
+	);
+
 	let required_downlevel_capabilities = E::required_downlevel_capabilities();
 	let downlevel_capabilities = adapter.get_downlevel_capabilities();
 	assert!(
@@ -246,7 +223,7 @@ async fn setup<E: Example>(title: &str) -> Setup {
 		.request_device(
 			&wgpu::DeviceDescriptor {
 				label: None,
-				features: (optional_features & adapter.features()) | required_features,
+				features: (optional_features & adapter_features) | required_features,
 				limits: needed_limits,
 			},
 			trace_dir.ok().as_ref().map(std::path::Path::new),
@@ -369,7 +346,7 @@ fn start<E: Example>(
 					println!("{:#?}", instance.generate_report());
 				}
 				_ => {
-					example.update(&device,&queue,event);
+					example.update(event);
 				}
 			},
 			event::Event::DeviceEvent {

src/lib.rs

@@ -0,0 +1,5 @@
+pub mod framework;
+pub mod body;
+pub mod zeroes;
+pub mod instruction;
+pub mod load_roblox;

src/load_roblox.rs

@@ -1,9 +1,3 @@
-use std::todo;
-
-use crate::model::{ModelData,ModelInstance};
-
-use crate::primitives;
-
 fn class_is_a(class: &str, superclass: &str) -> bool {
 	if class==superclass {
 		return true
@@ -16,125 +10,19 @@ fn class_is_a(class: &str, superclass: &str) -> bool {
 	}
 	return false
 }
-fn recursive_collect_superclass(objects: &mut std::vec::Vec<rbx_dom_weak::types::Ref>,dom: &rbx_dom_weak::WeakDom, instance: &rbx_dom_weak::Instance, superclass: &str){
-	for &referent in instance.children() {
-		if let Some(c) = dom.get_by_ref(referent) {
-			if class_is_a(c.class.as_str(), superclass) {
-				objects.push(c.referent());//copy ref
-			}
-			recursive_collect_superclass(objects,dom,c,superclass);
+
+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)?;
+
+	let mut objects = std::vec::Vec::<rbx_dom_weak::Instance>::new();
+	//move matching instances into objects
+	let (_,mut instances) = dom.into_raw();
+	for (_,instance) in instances.drain() {
+		if class_is_a(instance.class.as_str(), superclass) {
+			objects.push(instance);
 		}
 	}
-}
-fn get_texture_refs(dom:&rbx_dom_weak::WeakDom) -> Vec<rbx_dom_weak::types::Ref>{
-	let mut objects = std::vec::Vec::new();
-	recursive_collect_superclass(&mut objects, dom, dom.root(),"Decal");
-	//get ids
-	//clear vec
-	//next class
-	objects
-}
-
-struct RobloxAssetId(u64);
-struct RobloxAssetIdParseErr;
-impl std::str::FromStr for RobloxAssetId {
-    type Err=RobloxAssetIdParseErr;
-    fn from_str(s: &str) -> Result<Self, Self::Err>{
-        let regman=regex::Regex::new(r"(\d+)$").unwrap();
-        if let Some(captures) = regman.captures(s) {
-            if captures.len()==2{//captures[0] is all captures concatenated, and then each individual capture
-                if let Ok(id) = captures[0].parse::<u64>() {
-                    return Ok(Self(id));
-                }
-            }
-        }
-        Err(RobloxAssetIdParseErr)
-    }
-}
-pub fn generate_modeldatas_roblox(dom:rbx_dom_weak::WeakDom) -> Result<(Vec<ModelData>,Vec<String>,glam::Vec3), Box<dyn std::error::Error>>{
-	//ModelData includes texture dds
-	let mut spawn_point=glam::Vec3::ZERO;
-
-	//TODO: generate unit Block, Wedge, etc. after based on part shape lists
-	let mut modeldatas=crate::model::generate_modeldatas(primitives::the_unit_cube_lol(),ModelData::COLOR_FLOATS_WHITE);
-	let unit_cube_modeldata=modeldatas[0].clone();
-
-	let mut texture_id_from_asset_id=std::collections::HashMap::<u64,u32>::new();
-	let mut asset_id_from_texture_id=Vec::new();
-
-	let mut object_refs = std::vec::Vec::new();
-	let mut temp_objects = std::vec::Vec::new();
-	recursive_collect_superclass(&mut object_refs, &dom, dom.root(),"BasePart");
-	for object_ref in object_refs {
-		if let Some(object)=dom.get_by_ref(object_ref){
-			if let (
-					Some(rbx_dom_weak::types::Variant::CFrame(cf)),
-					Some(rbx_dom_weak::types::Variant::Vector3(size)),
-					Some(rbx_dom_weak::types::Variant::Float32(transparency)),
-					Some(rbx_dom_weak::types::Variant::Color3uint8(color3)),
-					Some(rbx_dom_weak::types::Variant::Enum(shape)),
-				) = (
-					object.properties.get("CFrame"),
-					object.properties.get("Size"),
-					object.properties.get("Transparency"),
-					object.properties.get("Color"),
-					object.properties.get("Shape"),//this will also skip unions
-				)
-			{
-				let model_instance=ModelInstance {
-						transform:glam::Mat4::from_translation(
-								glam::Vec3::new(cf.position.x,cf.position.y,cf.position.z)
-							)
-							* glam::Mat4::from_mat3(
-								glam::Mat3::from_cols(
-									glam::Vec3::new(cf.orientation.x.x,cf.orientation.y.x,cf.orientation.z.x),
-									glam::Vec3::new(cf.orientation.x.y,cf.orientation.y.y,cf.orientation.z.y),
-									glam::Vec3::new(cf.orientation.x.z,cf.orientation.y.z,cf.orientation.z.z),
-								),
-							)
-							* glam::Mat4::from_scale(
-								glam::Vec3::new(size.x,size.y,size.z)/2.0
-							),
-						color: glam::vec4(color3.r as f32/255f32, color3.g as f32/255f32, color3.b as f32/255f32, 1.0-*transparency),
-					};
-				if object.name=="MapStart"{
-					spawn_point=glam::Vec4Swizzles::xyz(model_instance.transform*glam::Vec3::Y.extend(1.0))+glam::vec3(0.0,2.5,0.0);
-					println!("Found MapStart{:?}",spawn_point);
-				}
-				if *transparency==1.0||shape.to_u32()!=1 {
-					continue;
-				}
-				temp_objects.clear();
-				recursive_collect_superclass(&mut temp_objects, &dom, object,"Decal");
-
-				let mut i_can_only_load_one_texture_per_model=None;
-				for &decal_ref in &temp_objects{
-					if let Some(decal)=dom.get_by_ref(decal_ref){
-						if let Some(rbx_dom_weak::types::Variant::Content(content)) = decal.properties.get("Texture") {
-							if let Ok(asset_id)=content.clone().into_string().parse::<RobloxAssetId>(){
-								if let Some(&texture_id)=texture_id_from_asset_id.get(&asset_id.0){
-									i_can_only_load_one_texture_per_model=Some(texture_id);
-								}else{
-									let texture_id=asset_id_from_texture_id.len();
-									texture_id_from_asset_id.insert(asset_id.0,texture_id as u32);
-									asset_id_from_texture_id.push(asset_id.0);
-									//make new model
-									let mut unit_cube_texture=unit_cube_modeldata.clone();
-									unit_cube_texture.texture=Some(texture_id as u32);
-									modeldatas.push(unit_cube_texture);
-								}
-							}
-						}
-					}
-				}
-				match i_can_only_load_one_texture_per_model{
-					//push to existing texture model
-					Some(texture_id)=>modeldatas[(texture_id+1) as usize].instances.push(model_instance),
-					//push instance to big unit cube in the sky
-					None=>modeldatas[0].instances.push(model_instance),
-				}
-			}
-		}
-	}
-	Ok((modeldatas,asset_id_from_texture_id.iter().map(|t|t.to_string()).collect(),spawn_point))
+
+	return Ok(objects)
 }

src/model.rs

@@ -1,70 +0,0 @@
-use bytemuck::{Pod, Zeroable};
-#[derive(Clone, Copy, Pod, Zeroable)]
-#[repr(C)]
-pub struct Vertex {
-	pub pos: [f32; 3],
-	pub texture: [f32; 2],
-	pub normal: [f32; 3],
-	pub color: [f32; 4],
-}
-
-#[derive(Clone)]
-pub struct ModelInstance {
-	pub transform: glam::Mat4,
-	pub color: glam::Vec4,
-}
-
-#[derive(Clone)]
-pub struct ModelData {
-	pub instances: Vec<ModelInstance>,
-	pub vertices: Vec<Vertex>,
-	pub entities: Vec<Vec<u16>>,
-	pub texture: Option<u32>,
-}
-
-impl ModelData {
-	pub const COLOR_FLOATS_WHITE: [f32;4] = [1.0,1.0,1.0,1.0];
-	pub const COLOR_VEC4_WHITE: glam::Vec4 = glam::vec4(1.0,1.0,1.0,1.0);
-}
-
-pub fn generate_modeldatas(data:obj::ObjData,color:[f32;4]) -> 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 {
-		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 {
-				for end_index in 2..poly.0.len() {
-					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);
-						}else{
-							let i=vertices.len() as u16;
-							vertices.push(Vertex {
-								pos: data.position[vert.0],
-								texture: data.texture[vert.1.unwrap()],
-								normal: data.normal[vert.2.unwrap()],
-								color,
-							});
-							vertex_index.insert(vert,i);
-							indices.push(i);
-						}
-					}
-				}
-			}
-			entities.push(indices);
-		}
-		modeldatas.push(ModelData {
-			instances: Vec::new(),
-			vertices:vertices.clone(),
-			entities,
-			texture: None,
-		});
-	}
-	modeldatas
-}

src/primitives.rs

@@ -1,76 +0,0 @@
-pub fn the_unit_cube_lol() -> obj::ObjData{
-	obj::ObjData{
-		position: vec![
-			[-1.,-1., 1.],//left bottom back
-			[ 1.,-1., 1.],//right bottom back
-			[ 1., 1., 1.],//right top back
-			[-1., 1., 1.],//left top back
-			[-1., 1.,-1.],//left top front
-			[ 1., 1.,-1.],//right top front
-			[ 1.,-1.,-1.],//right bottom front
-			[-1.,-1.,-1.],//left bottom front
-		],
-		texture: vec![[0.0,0.0],[1.0,0.0],[1.0,1.0],[0.0,1.0]],
-		normal: vec![
-			[1.,0.,0.],//AabbFace::Right
-			[0.,1.,0.],//AabbFace::Top
-			[0.,0.,1.],//AabbFace::Back
-			[-1.,0.,0.],//AabbFace::Left
-			[0.,-1.,0.],//AabbFace::Bottom
-			[0.,0.,-1.],//AabbFace::Front
-		],
-		objects: vec![obj::Object{
-			name: "Unit Cube".to_owned(),
-			groups: vec![obj::Group{
-				name: "Cube Vertices".to_owned(),
-				index: 0,
-				material: None,
-				polys: vec![
-					// back (0, 0, 1)
-					obj::SimplePolygon(vec![
-						obj::IndexTuple(0,Some(0),Some(2)),
-						obj::IndexTuple(1,Some(1),Some(2)),
-						obj::IndexTuple(2,Some(2),Some(2)),
-						obj::IndexTuple(3,Some(3),Some(2)),
-					]),
-					// front (0, 0,-1)
-					obj::SimplePolygon(vec![
-						obj::IndexTuple(4,Some(0),Some(5)),
-						obj::IndexTuple(5,Some(1),Some(5)),
-						obj::IndexTuple(6,Some(2),Some(5)),
-						obj::IndexTuple(7,Some(3),Some(5)),
-					]),
-					// right (1, 0, 0)
-					obj::SimplePolygon(vec![
-						obj::IndexTuple(6,Some(0),Some(0)),
-						obj::IndexTuple(5,Some(1),Some(0)),
-						obj::IndexTuple(2,Some(2),Some(0)),
-						obj::IndexTuple(1,Some(3),Some(0)),
-					]),
-					// left (-1, 0, 0)
-					obj::SimplePolygon(vec![
-						obj::IndexTuple(0,Some(0),Some(3)),
-						obj::IndexTuple(3,Some(1),Some(3)),
-						obj::IndexTuple(4,Some(2),Some(3)),
-						obj::IndexTuple(7,Some(3),Some(3)),
-					]),
-					// top (0, 1, 0)
-					obj::SimplePolygon(vec![
-						obj::IndexTuple(5,Some(1),Some(1)),
-						obj::IndexTuple(4,Some(0),Some(1)),
-						obj::IndexTuple(3,Some(3),Some(1)),
-						obj::IndexTuple(2,Some(2),Some(1)),
-					]),
-					// bottom (0,-1, 0)
-					obj::SimplePolygon(vec![
-						obj::IndexTuple(1,Some(1),Some(4)),
-						obj::IndexTuple(0,Some(0),Some(4)),
-						obj::IndexTuple(7,Some(3),Some(4)),
-						obj::IndexTuple(6,Some(2),Some(4)),
-					]),
-				],
-			}]
-		}],
-		material_libs: Vec::new(),
-	}
-}

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,71 +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
-const MAX_MODEL_INSTANCES=4096;
-@group(1)
-@binding(0)
-var<uniform> model_instances: array<ModelInstance, MAX_MODEL_INSTANCES>;
-@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);
 }

src/zeroes.rs

@@ -1,5 +1,4 @@
 //find roots of polynomials
-#[inline]
 pub fn zeroes2(a0:f32,a1:f32,a2:f32) -> Vec<f32>{
 	if a2==0f32{
 		return zeroes1(a0, a1);