dont handle edge of terrain properly

it's ok, it shouldn't be seen anyway and simplifies the code a lot, also makes a nice texture size that's divisible by 2 enough

engine/src/drawables/terrain.rs

@@ -1,6 +1,6 @@
 use crate::{
     bg_layout_litmesh, pbuffer::PBuffer, CompiledModule, Drawable, FrameContext, GfxContext,
-    IndexType, PipelineBuilder, RenderParams, Texture, Uniform, TL,
+    IndexType, PipelineBuilder, RenderParams, Texture, TextureBuilder, Uniform, TL,
 };
 use geom::{vec2, vec3, Camera, InfiniteFrustrum, Intersect3, Matrix4, Vec2, AABB3};
 use std::sync::Arc;
@@ -38,23 +38,33 @@ pub struct TerrainPrepared {
 
 impl<const CSIZE: usize, const CRESOLUTION: usize> TerrainRender<CSIZE, CRESOLUTION> {
     pub fn new(gfx: &mut GfxContext, w: u32, h: u32, grass: Arc<Texture>) -> Self {
+        debug_assert!(
+            CRESOLUTION >= 1 << LOD,
+            "TERRAIN RESOLUTION must be >= {}",
+            1 << LOD
+        );
+
         let indices = Self::generate_indices_mesh(gfx);
-        let mut tex = Texture::create_fbo(
-            &gfx.device,
-            (w * CRESOLUTION as u32 + 1, h * CRESOLUTION as u32 + 1),
+
+        let tex = TextureBuilder::empty(
+            w * CRESOLUTION as u32,
+            h * CRESOLUTION as u32,
+            1,
             TextureFormat::Rg16Uint,
-            TextureUsages::COPY_DST | TextureUsages::TEXTURE_BINDING,
-            None,
-        );
-        tex.sampler = gfx.device.create_sampler(&wgpu::SamplerDescriptor {
-            label: Some("texture sampler"),
+        )
+        .with_usage(TextureUsages::COPY_DST | TextureUsages::TEXTURE_BINDING)
+        .with_fixed_mipmaps(LOD as u32)
+        .with_sampler(wgpu::SamplerDescriptor {
+            label: Some("terrain sampler"),
             mag_filter: FilterMode::Linear,
             min_filter: FilterMode::Linear,
             address_mode_u: wgpu::AddressMode::ClampToEdge,
             address_mode_v: wgpu::AddressMode::ClampToEdge,
             address_mode_w: wgpu::AddressMode::ClampToEdge,
             ..Default::default()
-        });
+        })
+        .with_no_anisotropy()
+        .build(&gfx.device, &gfx.queue);
 
         let mut bgs = vec![];
         for lod in 0..LOD {
@@ -126,12 +136,7 @@ impl<const CSIZE: usize, const CRESOLUTION: usize> TerrainRender<CSIZE, CRESOLUT
             [a[0], a[1], b, c]
         }
 
-        // Need to add one more vertex on the edge of the map because when rendering a chunk
-        // we render "to the next chunk", which doesn't exist on the edge
-        let extrax = cell.0 + 1 == self.w;
-        let extray = cell.1 + 1 == self.h;
-        let mut contents =
-            Vec::with_capacity((CRESOLUTION + extrax as usize) * (CRESOLUTION + extray as usize));
+        let mut contents = Vec::with_capacity(CRESOLUTION * CRESOLUTION);
 
         let mut holder_y_edge: [f32; CRESOLUTION] = [0.0; CRESOLUTION];
         let mut j = 0;
@@ -161,23 +166,12 @@ impl<const CSIZE: usize, const CRESOLUTION: usize> TerrainRender<CSIZE, CRESOLUT
                 contents.extend(pack(height, dh_x, dh_y));
                 last_height = height;
             }
-            if extrax {
-                contents.extend(pack(ys[ys.len() - 1], 0.0, 0.0));
-            }
 
             last_ys = ys;
         }
-        if extray {
-            for i in 0..CRESOLUTION {
-                contents.extend(pack(chunk[CRESOLUTION - 1][i], 0.0, 0.0));
-            }
-            if extrax {
-                contents.extend(pack(chunk[CRESOLUTION - 1][CRESOLUTION - 1], 0.0, 0.0));
-            }
-        }
 
-        let w = CRESOLUTION as u32 + extrax as u32;
-        let h = CRESOLUTION as u32 + extray as u32;
+        let h = CRESOLUTION as u32;
+        let w = CRESOLUTION as u32;
 
         gfx.queue.write_texture(
             ImageCopyTexture {

engine/src/texture.rs

@@ -287,6 +287,8 @@ pub struct TextureBuilder<'a> {
     mipmaps: Option<CompiledModule>,
     mipmaps_no_gen: bool,
     fixed_mipmaps: Option<u32>,
+    usage: TextureUsages,
+    no_anisotropy: bool,
 }
 
 impl<'a> TextureBuilder<'a> {
@@ -295,11 +297,21 @@ impl<'a> TextureBuilder<'a> {
         self
     }
 
+    pub fn with_usage(mut self, usage: TextureUsages) -> Self {
+        self.usage = usage;
+        self
+    }
+
     pub fn with_sampler(mut self, sampler: SamplerDescriptor<'static>) -> Self {
         self.sampler = sampler;
         self
     }
 
+    pub fn with_no_anisotropy(mut self) -> Self {
+        self.no_anisotropy = true;
+        self
+    }
+
     pub fn with_srgb(mut self, srgb: bool) -> Self {
         self.srgb = srgb;
         self
@@ -377,6 +389,10 @@ impl<'a> TextureBuilder<'a> {
             mipmaps: None,
             mipmaps_no_gen: false,
             fixed_mipmaps: None,
+            usage: TextureUsages::TEXTURE_BINDING
+                | TextureUsages::COPY_DST
+                | TextureUsages::RENDER_ATTACHMENT,
+            no_anisotropy: false,
         }
     }
 
@@ -391,6 +407,10 @@ impl<'a> TextureBuilder<'a> {
             mipmaps: None,
             mipmaps_no_gen: false,
             fixed_mipmaps: None,
+            usage: TextureUsages::TEXTURE_BINDING
+                | TextureUsages::COPY_DST
+                | TextureUsages::RENDER_ATTACHMENT,
+            no_anisotropy: false,
         }
     }
 
@@ -461,9 +481,7 @@ impl<'a> TextureBuilder<'a> {
             sample_count: 1,
             dimension: wgpu::TextureDimension::D2,
             format,
-            usage: TextureUsages::TEXTURE_BINDING
-                | TextureUsages::COPY_DST
-                | TextureUsages::RENDER_ATTACHMENT,
+            usage: self.usage,
             view_formats: &[],
         });
 
@@ -512,6 +530,7 @@ impl<'a> TextureBuilder<'a> {
         if mip_level_count > 1
             && (sampl.min_filter == wgpu::FilterMode::Linear
                 || sampl.mag_filter == wgpu::FilterMode::Linear)
+            && !self.no_anisotropy
         {
             sampl.anisotropy_clamp = 16;
         }