scope skybox

src/main.rs

@@ -113,20 +113,29 @@ impl Camera {
 	}
 }
 
-pub struct Skybox {
+pub struct GraphicsBindGroups {
+	camera: wgpu::BindGroup,
+	skybox_texture: wgpu::BindGroup,
+}
+
+pub struct GraphicsPipelines {
+	skybox: wgpu::RenderPipeline,
+	model: wgpu::RenderPipeline,
+}
+
+pub struct GraphicsData {
 	start_time: std::time::Instant,
 	camera: Camera,
 	physics: strafe_client::body::PhysicsState,
-	sky_pipeline: wgpu::RenderPipeline,
+	pipelines: GraphicsPipelines,
-	entity_pipeline: wgpu::RenderPipeline,
+	bind_groups: GraphicsBindGroups,
-	main_bind_group: wgpu::BindGroup,
 	camera_buf: wgpu::Buffer,
 	models: Vec<ModelGraphics>,
 	depth_view: wgpu::TextureView,
 	staging_belt: wgpu::util::StagingBelt,
 }
 
-impl Skybox {
+impl GraphicsData {
 	const DEPTH_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Depth24Plus;
 
 	fn create_depth_texture(
@@ -211,7 +220,7 @@ fn add_obj(device:&wgpu::Device,modeldatas:& mut Vec<ModelData>,data:obj::ObjDat
 	}
 }
 
-impl strafe_client::framework::Example for Skybox {
+impl strafe_client::framework::Example for GraphicsData {
 	fn optional_features() -> wgpu::Features {
 		wgpu::Features::TEXTURE_COMPRESSION_ASTC
 			| wgpu::Features::TEXTURE_COMPRESSION_ETC2
@@ -258,8 +267,44 @@ impl strafe_client::framework::Example for Skybox {
 		modeldatas[2].transforms[0]=glam::Mat4::from_translation(glam::vec3(-10.,5.,10.));
 		modeldatas[3].transforms[0]=glam::Mat4::from_translation(glam::vec3(0.,0.,0.))*glam::Mat4::from_scale(glam::vec3(160.0, 1.0, 160.0));
 
-		let main_bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+		let camera_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,
+				},
+			],
+		});
+		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,
@@ -277,7 +322,7 @@ impl strafe_client::framework::Example for Skybox {
 					ty: wgpu::BindingType::Texture {
 						sample_type: wgpu::TextureSampleType::Float { filterable: true },
 						multisampled: false,
-						view_dimension: wgpu::TextureViewDimension::Cube,
+						view_dimension: wgpu::TextureViewDimension::D2,
 					},
 					count: None,
 				},
@@ -289,20 +334,26 @@ impl strafe_client::framework::Example for Skybox {
 				},
 			],
 		});
-		let model_bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+
-			label: Some("Model"),
+		let clamp_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
-			entries: &[
+			label: Some("Clamp Sampler"),
-				wgpu::BindGroupLayoutEntry {
+			address_mode_u: wgpu::AddressMode::ClampToEdge,
-					binding: 0,
+			address_mode_v: wgpu::AddressMode::ClampToEdge,
-					visibility: wgpu::ShaderStages::VERTEX,
+			address_mode_w: wgpu::AddressMode::ClampToEdge,
-					ty: wgpu::BindingType::Buffer {
+			mag_filter: wgpu::FilterMode::Linear,
-						ty: wgpu::BufferBindingType::Uniform,
+			min_filter: wgpu::FilterMode::Linear,
-						has_dynamic_offset: false,
+			mipmap_filter: wgpu::FilterMode::Linear,
-						min_binding_size: None,
+			..Default::default()
-					},
+		});
-					count: None,
+		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
@@ -339,121 +390,10 @@ impl strafe_client::framework::Example for Skybox {
     		hitbox_halfsize: glam::vec3(1.0,2.5,1.0),
 		};
 
-		let camera_uniforms = camera.to_uniform_data(physics.body.extrapolated_position(0));
+		//load textures
-		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_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-				label: Some(format!("ModelGraphics{}",i).as_str()),
-				contents: bytemuck::cast_slice(&model_uniforms),
-				usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-			});
-			let model_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-				layout: &model_bind_group_layout,
-				entries: &[
-					wgpu::BindGroupEntry {
-						binding: 0,
-						resource: model_buf.as_entire_binding(),
-					},
-				],
-				label: Some(format!("ModelGraphics{}",i).as_str()),
-			});
-			//all of these are being moved here
-			models.push(ModelGraphics{
-				transforms: modeldata.transforms,
-				vertex_buf:modeldata.vertex_buf,
-				entities: modeldata.entities,
-				bind_group: model_bind_group,
-				model_buf,
-			})
-		}
-
-		let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-			label: None,
-			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"),
-			layout: Some(&pipeline_layout),
-			vertex: wgpu::VertexState {
-				module: &shader,
-				entry_point: "vs_sky",
-				buffers: &[],
-			},
-			fragment: Some(wgpu::FragmentState {
-				module: &shader,
-				entry_point: "fs_sky",
-				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: false,
-				depth_compare: wgpu::CompareFunction::LessEqual,
-				stencil: wgpu::StencilState::default(),
-				bias: wgpu::DepthBiasState::default(),
-			}),
-			multisample: wgpu::MultisampleState::default(),
-			multiview: None,
-		});
-		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",
-				buffers: &[wgpu::VertexBufferLayout {
-					array_stride: std::mem::size_of::<Vertex>() as wgpu::BufferAddress,
-					step_mode: wgpu::VertexStepMode::Vertex,
-					attributes: &wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x2, 2 => Float32x3],
-				}],
-			},
-			fragment: Some(wgpu::FragmentState {
-				module: &shader,
-				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 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 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 {
@@ -502,6 +442,46 @@ impl strafe_client::framework::Example for Skybox {
 				_ => 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(
@@ -511,47 +491,173 @@ impl strafe_client::framework::Example for Skybox {
 					mip_level_count: max_mips,
 					sample_count: 1,
 					dimension: wgpu::TextureDimension::D2,
-				format: skybox_format,
+					format: wgpu::TextureFormat::Bc7RgbaUnorm,
 					usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
-				label: None,
+					label: Some("Squid Texture"),
 					view_formats: &[],
 				},
 				&image.data,
 			);
 
-		let texture_view = texture.create_view(&wgpu::TextureViewDescriptor {
+			texture.create_view(&wgpu::TextureViewDescriptor {
-			label: None,
+				label: Some("Squid Texture View"),
-			dimension: Some(wgpu::TextureViewDimension::Cube),
+				dimension: Some(wgpu::TextureViewDimension::D2),
 				..wgpu::TextureViewDescriptor::default()
+			})
+		};
+
+		//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_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+				label: Some(format!("ModelGraphics{}",i).as_str()),
+				contents: bytemuck::cast_slice(&model_uniforms),
+				usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
 			});
-		let main_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+			let model_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-			layout: &main_bind_group_layout,
+				layout: &model_bind_group_layout,
+				entries: &[
+					wgpu::BindGroupEntry {
+						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()),
+			});
+			//all of these are being moved here
+			models.push(ModelGraphics{
+				transforms: modeldata.transforms,
+				vertex_buf:modeldata.vertex_buf,
+				entities: modeldata.entities,
+				bind_group: model_bind_group,
+				model_buf,
+			})
+		}
+
+		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,
+			],
+			push_constant_ranges: &[],
+		});
+
+		// Create the render pipelines
+		let sky_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+			label: Some("Sky Pipeline"),
+			layout: Some(&pipeline_layout),
+			vertex: wgpu::VertexState {
+				module: &shader,
+				entry_point: "vs_sky",
+				buffers: &[],
+			},
+			fragment: Some(wgpu::FragmentState {
+				module: &shader,
+				entry_point: "fs_sky",
+				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: false,
+				depth_compare: wgpu::CompareFunction::LessEqual,
+				stencil: wgpu::StencilState::default(),
+				bias: wgpu::DepthBiasState::default(),
+			}),
+			multisample: wgpu::MultisampleState::default(),
+			multiview: None,
+		});
+		let model_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+			label: Some("Model Pipeline"),
+			layout: Some(&pipeline_layout),
+			vertex: wgpu::VertexState {
+				module: &shader,
+				entry_point: "vs_entity_texture",
+				buffers: &[wgpu::VertexBufferLayout {
+					array_stride: std::mem::size_of::<Vertex>() as wgpu::BufferAddress,
+					step_mode: wgpu::VertexStepMode::Vertex,
+					attributes: &wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x2, 2 => Float32x3],
+				}],
+			},
+			fragment: Some(wgpu::FragmentState {
+				module: &shader,
+				entry_point: "fs_entity_texture",
+				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 camera_uniforms = camera.to_uniform_data(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 camera_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+			layout: &camera_bind_group_layout,
 			entries: &[
 				wgpu::BindGroupEntry {
 					binding: 0,
 					resource: camera_buf.as_entire_binding(),
 				},
-				wgpu::BindGroupEntry {
-					binding: 1,
-					resource: wgpu::BindingResource::TextureView(&texture_view),
-				},
-				wgpu::BindGroupEntry {
-					binding: 2,
-					resource: wgpu::BindingResource::Sampler(&sampler),
-				},
 			],
 			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),
+				},
+			],
+			label: Some("Sky Texture"),
+		});
 
 		let depth_view = Self::create_depth_texture(config, device);
 
-		Skybox {
+		GraphicsData {
 			start_time: Instant::now(),
 			camera,
 			physics,
-			sky_pipeline,
+			pipelines:GraphicsPipelines{
-			entity_pipeline,
+				skybox:sky_pipeline,
-			main_bind_group,
+				model:model_pipeline
+			},
+			bind_groups:GraphicsBindGroups{
+				camera:camera_bind_group,
+				skybox_texture:skybox_texture_bind_group,
+			},
 			camera_buf,
 			models,
 			depth_view,
@@ -722,9 +828,10 @@ impl strafe_client::framework::Example for Skybox {
 				}),
 			});
 
-			rpass.set_bind_group(0, &self.main_bind_group, &[]);
+			rpass.set_bind_group(0, &self.bind_groups.camera, &[]);
+			rpass.set_bind_group(2, &self.bind_groups.skybox_texture, &[]);
 
-			rpass.set_pipeline(&self.entity_pipeline);
+			rpass.set_pipeline(&self.pipelines.model);
 			for model in self.models.iter() {
 				rpass.set_bind_group(1, &model.bind_group, &[]);
 				rpass.set_vertex_buffer(0, model.vertex_buf.slice(..));
@@ -735,7 +842,7 @@ impl strafe_client::framework::Example for Skybox {
 				}
 			}
 
-			rpass.set_pipeline(&self.sky_pipeline);
+			rpass.set_pipeline(&self.pipelines.skybox);
 			rpass.draw(0..3, 0..1);
 		}
 
@@ -746,7 +853,7 @@ impl strafe_client::framework::Example for Skybox {
 }
 
 fn main() {
-	strafe_client::framework::run::<Skybox>(
+	strafe_client::framework::run::<GraphicsData>(
 		format!("Strafe Client v{}",
 			env!("CARGO_PKG_VERSION")
 		).as_str()

src/shader.wgsl

@@ -1,9 +1,4 @@
-struct SkyOutput {
+struct Camera {
-	@builtin(position) position: vec4<f32>,
-	@location(0) sampledir: vec3<f32>,
-};
-
-struct Data {
 	// from camera to screen
 	proj: mat4x4<f32>,
 	// from screen to camera
@@ -13,9 +8,16 @@ struct Data {
 	// camera position
 	cam_pos: vec4<f32>,
 };
+
+//group 0 is the camera
 @group(0)
 @binding(0)
-var<uniform> r_data: Data;
+var<uniform> camera: Camera;
+
+struct SkyOutput {
+	@builtin(position) position: vec4<f32>,
+	@location(0) sampledir: vec3<f32>,
+};
 
 @vertex
 fn vs_sky(@builtin(vertex_index) vertex_index: u32) -> SkyOutput {
@@ -30,8 +32,8 @@ fn vs_sky(@builtin(vertex_index) vertex_index: u32) -> SkyOutput {
 	);
 
 	// transposition = inversion for this orthonormal matrix
-	let inv_model_view = transpose(mat3x3<f32>(r_data.view[0].xyz, r_data.view[1].xyz, r_data.view[2].xyz));
+	let inv_model_view = transpose(mat3x3<f32>(camera.view[0].xyz, camera.view[1].xyz, camera.view[2].xyz));
-	let unprojected = r_data.proj_inv * pos;
+	let unprojected = camera.proj_inv * pos;
 
 	var result: SkyOutput;
 	result.sampledir = inv_model_view * unprojected.xyz;
@@ -39,54 +41,65 @@ fn vs_sky(@builtin(vertex_index) vertex_index: u32) -> SkyOutput {
 	return result;
 }
 
-struct EntityOutput {
+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 EntityOutputTexture {
 	@builtin(position) position: vec4<f32>,
 	@location(1) texture: vec2<f32>,
 	@location(2) normal: vec3<f32>,
 	@location(3) view: vec3<f32>,
 };
-const MAX_ENTITY_INSTANCES=1024;
-@group(1)
-@binding(0)
-var<uniform> r_EntityTransform: array<mat4x4<f32>,MAX_ENTITY_INSTANCES>;
-
 @vertex
-fn vs_entity(
+fn vs_entity_texture(
 	@builtin(instance_index) instance: u32,
 	@location(0) pos: vec3<f32>,
 	@location(1) texture: vec2<f32>,
 	@location(2) normal: vec3<f32>,
-) -> EntityOutput {
+) -> EntityOutputTexture {
-	var position: vec4<f32> = r_EntityTransform[instance] * vec4<f32>(pos, 1.0);
+	var position: vec4<f32> = entity_transforms[instance] * vec4<f32>(pos, 1.0);
-	var result: EntityOutput;
+	var result: EntityOutputTexture;
-	result.normal = (r_EntityTransform[instance] * vec4<f32>(normal, 0.0)).xyz;
+	result.normal = (entity_transforms[instance] * vec4<f32>(normal, 0.0)).xyz;
-	result.texture=texture;
+	result.texture=texture;//(entity_texture_transforms[instance] * vec3<f32>(texture, 1.0)).xy;
-	result.view = position.xyz - r_data.cam_pos.xyz;
+	result.view = position.xyz - camera.cam_pos.xyz;
-	result.position = r_data.proj * r_data.view * position;
+	result.position = camera.proj * camera.view * position;
 	return result;
 }
 
-@group(0)
+//group 2 is the skybox texture
+@group(2)
+@binding(0)
+var cube_texture: texture_cube<f32>;
+@group(2)
 @binding(1)
-var r_texture: texture_cube<f32>;
+var cube_sampler: sampler;
-@group(0)
-@binding(2)
-var r_sampler: sampler;
 
 @fragment
 fn fs_sky(vertex: SkyOutput) -> @location(0) vec4<f32> {
-	return textureSample(r_texture, r_sampler, vertex.sampledir);
+	return textureSample(cube_texture, model_sampler, vertex.sampledir);
 }
 
 @fragment
-fn fs_entity(vertex: EntityOutput) -> @location(0) vec4<f32> {
+fn fs_entity_texture(vertex: EntityOutputTexture) -> @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 dir = vec3<f32>(-1.0)+2.0*vec3<f32>(vertex.texture.x,0.0,vertex.texture.y);
+	let fragment_color = textureSample(model_texture, model_sampler, vertex.texture).rgb;
-	let texture_color = textureSample(r_texture, r_sampler, dir).rgb;
+	let reflected_color = textureSample(cube_texture, cube_sampler, reflected).rgb;
-	let reflected_color = textureSample(r_texture, r_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);
-	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);
 }