removed tiled rendering mode

25 files changed, 44 insertions, 805 deletions

diff --git a/example/build.rs b/example/build.rs
index f7d8f06..fd5ea34 100644
--- a/example/build.rs
+++ b/example/build.rs
@@ -27,7 +27,6 @@ fn main() {
     let mut packer = AssetPacker::new(Path::new(assets_dir));
     packer.cargo_rerun_if_changed();
     packer.sprites(Path::new("src_assets/sprites"));
-    packer.tiles(Path::new("src_assets/tiles"));
     packer.music(Path::new("src_assets/music"));
     packer.sounds(Path::new("src_assets/sounds"));
     if is_wasm { packer.gen_javascript_and_html(); }
diff --git a/example/src/main.rs b/example/src/main.rs
index 042da6a..b4e0942 100644
--- a/example/src/main.rs
+++ b/example/src/main.rs
@@ -18,7 +18,7 @@ use gate::{App, AppContext, AppInfo, KeyCode};
 use gate::renderer::{Renderer, Affine};
 
 mod asset_id { include!(concat!(env!("OUT_DIR"), "/asset_id.rs")); }
-use asset_id::{AssetId, SpriteId, TileId, MusicId, SoundId};
+use asset_id::{AssetId, SpriteId, MusicId, SoundId};
 
 // Note: the assets that we placed in the src_assets directory can be referenced using the
 //       SpriteId, TileId, MusicId, and SoundId enums
@@ -92,7 +92,18 @@ impl App<AssetId> for TowerGame {
 
     fn render(&mut self, renderer: &mut Renderer<AssetId>, ctx: &AppContext<AssetId>) {
         let (app_width, app_height) = ctx.dims();
-        { // drawing tiles
+        let mut renderer = renderer.sprite_mode();
+        for x in 0..((app_width / 16.).ceil() as usize) {
+            for y in 0..((app_height / 16.).ceil() as usize) {
+                let affine = Affine::translate(
+                    8. + x as f64 * 16. - 0.5 * app_width,
+                    8. + y as f64 * 16. - 0.5 * app_height,
+                );
+                let tile = if (x + y) % 2 == 0 { SpriteId::BgTileR0C0 } else { SpriteId::BgTileR0C1 };
+                renderer.draw(&affine, tile);
+            }
+        }
+        /*{ // drawing tiles
             let mut renderer = renderer.tiled_mode(0.5 * app_width, 0.5 * app_height);
             for x in 0..((app_width / 16.).ceil() as usize) {
                 for y in 0..((app_height / 16.).ceil() as usize) {
@@ -101,22 +112,19 @@ impl App<AssetId> for TowerGame {
                     renderer.draw(&affine, tile);
                 }
             }
-        }
-        { // drawing sprites
-            let mut renderer = renderer.sprite_mode();
-            let base = Affine::scale(0.5).pre_translate(0., -10.);
-            renderer.draw(&base, SpriteId::Pillars);
-            for pillar_index in 0..self.pillars.len() {
-                let pillar = &self.pillars[pillar_index];
-                for height_index in 0..pillar.len() {
-                    let pos = disc_pos(pillar_index, height_index);
-                    renderer.draw(&base.pre_translate(pos.0, pos.1), disc_sprite(pillar[height_index]));
-                }
-            }
-            if let Some(held) = self.held.as_ref() {
-                renderer.draw(&base.pre_translate(held.pos.0, held.pos.1), disc_sprite(held.value));
+        }*/
+        let base = Affine::scale(0.5).pre_translate(0., -10.);
+        renderer.draw(&base, SpriteId::Pillars);
+        for pillar_index in 0..self.pillars.len() {
+            let pillar = &self.pillars[pillar_index];
+            for height_index in 0..pillar.len() {
+                let pos = disc_pos(pillar_index, height_index);
+                renderer.draw(&base.pre_translate(pos.0, pos.1), disc_sprite(pillar[height_index]));
             }
         }
+        if let Some(held) = self.held.as_ref() {
+            renderer.draw(&base.pre_translate(held.pos.0, held.pos.1), disc_sprite(held.value));
+        }
     }
 }
 
diff --git a/example/src_assets/tiles/BgTile_t16.png b/example/src_assets/sprites/BgTile_t16.png
index 48b3171..48b3171 100644
--- a/example/src_assets/tiles/BgTile_t16.png
+++ b/example/src_assets/sprites/BgTile_t16.png
diff --git a/gate/src/asset_id.rs b/gate/src/asset_id.rs
index 0281b79..9052325 100644
--- a/gate/src/asset_id.rs
+++ b/gate/src/asset_id.rs
@@ -38,8 +38,6 @@ pub trait IdU16: Sized {
 pub trait AppAssetId {
     /// Sprite asset enum
     type Sprite: IdU16;
-    /// Tile asset enum
-    type Tile: IdU16;
     /// Music asset enum
     type Music: IdU16;
     /// Sound asset enum
diff --git a/gate/src/core/sdl/mod.rs b/gate/src/core/sdl/mod.rs
index adef424..6f823a2 100644
--- a/gate/src/core/sdl/mod.rs
+++ b/gate/src/core/sdl/mod.rs
@@ -108,9 +108,8 @@ pub fn run<AS: AppAssetId, AP: App<AS>>(info: AppInfo, mut app: AP) {
 }
 
 fn build_renderer<AS: AppAssetId>(info: &AppInfo, sdl_renderer: &SdlRenderer) -> Renderer<AS> {
-    let sprites_atlas = Atlas::new_sprite(BufReader::new(File::open("assets/sprites.atlas").unwrap()));
-    let tiles_atlas = Atlas::new_tiled(BufReader::new(File::open("assets/tiles.atlas").unwrap()));
-    let render_buffer = RenderBuffer::new(&info, info.window_pixels, sprites_atlas, tiles_atlas);
+    let sprites_atlas = Atlas::new(BufReader::new(File::open("assets/sprites.atlas").unwrap())).unwrap();
+    let render_buffer = RenderBuffer::new(&info, info.window_pixels, sprites_atlas);
 
     let mut sprites_tex = sdl_renderer.load_texture(Path::new("assets/sprites.png")).unwrap();
     unsafe {
@@ -119,9 +118,8 @@ fn build_renderer<AS: AppAssetId>(info: &AppInfo, sdl_renderer: &SdlRenderer) ->
         gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::LINEAR as GLint);
         sprites_tex.gl_unbind_texture();
     }
-    let tiles_tex = sdl_renderer.load_texture(Path::new("assets/tiles.png")).unwrap();
     // TODO need to ensure Nearest-neighbor sampling is used?
-    let core_renderer = CoreRenderer::new(&render_buffer, sprites_tex, tiles_tex);
+    let core_renderer = CoreRenderer::new(sprites_tex);
 
     Renderer::<AS>::new(render_buffer, core_renderer)
 }
diff --git a/gate/src/core/wasm/mod.rs b/gate/src/core/wasm/mod.rs
index 10104db..f7f0881 100644
--- a/gate/src/core/wasm/mod.rs
+++ b/gate/src/core/wasm/mod.rs
@@ -101,16 +101,10 @@ impl<AS: AppAssetId, AP: App<AS>> TraitAppRunner for AppRunner<AS, AP> {
             atlas_buf = vec![0; gateWasmSpriteAtlasBinSize()];
             gateWasmSpriteAtlasBinFill(mem::transmute(&mut atlas_buf[0]));
         }
-        let sprite_atlas = Atlas::new_sprite(Cursor::new(atlas_buf));
+        let sprite_atlas = Atlas::new(Cursor::new(atlas_buf)).unwrap();
 
-        unsafe {
-            atlas_buf = vec![0; gateWasmTiledAtlasBinSize()];
-            gateWasmTiledAtlasBinFill(mem::transmute(&mut atlas_buf[0]));
-        }
-        let tiled_atlas = Atlas::new_tiled(Cursor::new(atlas_buf));
-
-        let render_buffer = RenderBuffer::new(&self.info, self.info.window_pixels, sprite_atlas, tiled_atlas);
-        let core_renderer = CoreRenderer::new(&render_buffer);
+        let render_buffer = RenderBuffer::new(&self.info, self.info.window_pixels, sprite_atlas);
+        let core_renderer = CoreRenderer::new();
         self.renderer = Some(Renderer::<AS>::new(render_buffer, core_renderer));
 
         self.ctx.set_dims(self.renderer.as_ref().unwrap().app_dims());
diff --git a/gate/src/core/wasm/wasm_exports.rs b/gate/src/core/wasm/wasm_exports.rs
index 42716af..4d9ee22 100644
--- a/gate/src/core/wasm/wasm_exports.rs
+++ b/gate/src/core/wasm/wasm_exports.rs
@@ -82,23 +82,3 @@ pub unsafe extern "C" fn gateWasmSpriteVertSrc() -> *const c_char {
 pub unsafe extern "C" fn gateWasmSpriteFragSrc() -> *const c_char {
     shaders::FS_SPRITE_SRC
 }
-
-#[no_mangle]
-pub unsafe extern "C" fn gateWasmTiledVertSrc() -> *const c_char {
-    shaders::VS_TILED_SRC
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn gateWasmTiledFragSrc() -> *const c_char {
-    shaders::FS_TILED_SRC
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn gateWasmFromTiledVertSrc() -> *const c_char {
-    shaders::VS_FROM_TILED_SRC
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn gateWasmFromTiledFragSrc() -> *const c_char {
-    shaders::FS_FROM_TILED_SRC
-}
diff --git a/gate/src/core/wasm/wasm_imports.rs b/gate/src/core/wasm/wasm_imports.rs
index 79f2256..c99757b 100644
--- a/gate/src/core/wasm/wasm_imports.rs
+++ b/gate/src/core/wasm/wasm_imports.rs
@@ -18,13 +18,10 @@
 use std::os::raw::{c_void, c_int};
 
 extern {
-    pub fn gateWasmSetTiledFboDims(w: c_int, h: c_int);
     pub fn gateWasmSetScissor(x: c_int, y: c_int, w: c_int, h: c_int);
 
     pub fn gateWasmClear(r: f32, g: f32, b: f32);
     pub fn gateWasmDrawSprites(size: usize, data: *const c_void);
-    pub fn gateWasmDrawTilesToFbo(size: usize, data: *const c_void);
-    pub fn gateWasmDrawTilesFromFbo(size: usize, data: *const c_void, app_pixel_scalar: f32);
 
     pub fn gateWasmPlaySound(id: c_int);
     pub fn gateWasmLoopMusic(id: c_int);
diff --git a/gate/src/renderer/atlas.rs b/gate/src/renderer/atlas.rs
index bc4a73f..893abc0 100644
--- a/gate/src/renderer/atlas.rs
+++ b/gate/src/renderer/atlas.rs
@@ -17,16 +17,16 @@ use std::collections::HashMap;
 
 use byteorder::BigEndian;
 
+const PAD: u16 = 1;
+
 pub struct Atlas {
+    #[allow(dead_code)] // dims might not used when targeting wasm
     pub(super) dims: (f32, f32),
     pub(super) images: HashMap<u16, ImageCoords>,
 }
 
 impl Atlas {
-    pub fn new_sprite<R: Read>(input: R) -> Atlas { Atlas::new(input, 1).unwrap() }
-    pub fn new_tiled<R: Read>(input: R) -> Atlas { Atlas::new(input, 0).unwrap() }
-
-    fn new<R: Read>(mut input: R, pad: u16) -> io::Result<Atlas> {
+    pub fn new<R: Read>(mut input: R) -> io::Result<Atlas> {
         use byteorder::ReadBytesExt;
 
         let dims = (input.read_u16::<BigEndian>()? as f32, input.read_u16::<BigEndian>()? as f32);
@@ -35,8 +35,8 @@ impl Atlas {
         let mut images = HashMap::with_capacity(handle_count as usize);
         for id in 0..handle_count {
             let image = ImageCoords {
-                lt: ((input.read_u16::<BigEndian>()? - pad) as f32, (input.read_u16::<BigEndian>()? - pad) as f32),
-                rb: ((input.read_u16::<BigEndian>()? + pad) as f32, (input.read_u16::<BigEndian>()? + pad) as f32),
+                lt: ((input.read_u16::<BigEndian>()? - PAD) as f32, (input.read_u16::<BigEndian>()? - PAD) as f32),
+                rb: ((input.read_u16::<BigEndian>()? + PAD) as f32, (input.read_u16::<BigEndian>()? + PAD) as f32),
                 anchor: (0.5 * input.read_i16::<BigEndian>()? as f32, 0.5 * input.read_i16::<BigEndian>()? as f32),
             };
             images.insert(id, image);
diff --git a/gate/src/renderer/core_renderer/sdl/from_tiled_program.rs b/gate/src/renderer/core_renderer/sdl/from_tiled_program.rs
deleted file mode 100644
index e3c9ba7..0000000
--- a/gate/src/renderer/core_renderer/sdl/from_tiled_program.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-// Copyright 2017-2018 Matthew D. Michelotti
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::{ptr, str, mem};
-use std::os::raw::{c_void, c_char};
-
-use gl::types::*;
-use gl;
-
-use super::shader_util;
-use renderer::shaders;
-
-pub struct FromTiledProgram {
-    pub handle: GLuint,
-    pub vao: GLuint,
-    vs: GLuint,
-    fs: GLuint,
-    pub uniform_tex: GLint,
-    pub uniform_inv_tex_dims: GLint,
-    pub uniform_inv_tex_sample_dim: GLint,
-}
-
-impl FromTiledProgram {
-    pub fn new() -> FromTiledProgram {
-        let vs = shader_util::compile_shader(shaders::VS_FROM_TILED_SRC, gl::VERTEX_SHADER);
-        let fs = shader_util::compile_shader(shaders::FS_FROM_TILED_SRC, gl::FRAGMENT_SHADER);
-        let handle = shader_util::link_program(vs, fs);
-        let vao = FromTiledProgram::make_vao(handle);
-        unsafe {
-            FromTiledProgram {
-                handle, vao, vs, fs,
-                uniform_tex: gl::GetUniformLocation(handle, c_str!("tex")),
-                uniform_inv_tex_dims: gl::GetUniformLocation(handle, c_str!("inv_tex_dims")),
-                uniform_inv_tex_sample_dim: gl::GetUniformLocation(handle, c_str!("inv_tex_sample_dim")),
-            }
-        }
-    }
-
-    fn make_vao(program_handle: GLuint) -> GLuint {
-        let mut vao = 0;
-        unsafe {
-            let attrib_vert = gl::GetAttribLocation(program_handle, c_str!("vert"));
-            let attrib_vs_tex_vert_rb = gl::GetAttribLocation(program_handle, c_str!("vs_tex_vert_rb"));
-
-            gl::GenVertexArrays(1, &mut vao);
-            gl::BindVertexArray(vao);
-
-            // TODO be consistent with the gl::TRUE/FALSE values in gl::VertexAttribPointer...
-
-            gl::EnableVertexAttribArray(attrib_vert as GLuint);
-            gl::VertexAttribPointer(attrib_vert as GLuint, 2, gl::FLOAT, gl::FALSE, 4*mem::size_of::<GLfloat>() as i32, ptr::null());
-
-            gl::EnableVertexAttribArray(attrib_vs_tex_vert_rb as GLuint);
-            gl::VertexAttribPointer(attrib_vs_tex_vert_rb as GLuint, 2, gl::FLOAT, gl::TRUE, 4*mem::size_of::<GLfloat>() as i32,
-                                    (2 * mem::size_of::<GLfloat>()) as *const c_void);
-
-            gl::BindVertexArray(0);
-        }
-        vao
-    }
-}
-
-impl Drop for FromTiledProgram {
-    fn drop(&mut self) {
-        unsafe {
-            gl::DeleteProgram(self.handle);
-            gl::DeleteShader(self.fs);
-            gl::DeleteShader(self.vs);
-            gl::DeleteVertexArrays(1, &self.vao);
-        }
-    }
-}
diff --git a/gate/src/renderer/core_renderer/sdl/mod.rs b/gate/src/renderer/core_renderer/sdl/mod.rs
index 374b1e7..8507cc7 100644
--- a/gate/src/renderer/core_renderer/sdl/mod.rs
+++ b/gate/src/renderer/core_renderer/sdl/mod.rs
@@ -14,8 +14,6 @@
 
 mod shader_util;
 mod sprite_program;
-mod tiled_program;
-mod from_tiled_program;
 
 use std::mem;
 
@@ -26,31 +24,21 @@ use gl;
 
 use ::renderer::render_buffer::RenderBuffer;
 use self::sprite_program::SpriteProgram;
-use self::tiled_program::TiledProgram;
-use self::from_tiled_program::FromTiledProgram;
 
 pub struct CoreRenderer {
     vbo: GLuint,
     sprite_program: SpriteProgram,
-    tiled_program: TiledProgram,
-    from_tiled_program: FromTiledProgram,
     sprites_tex: Texture,
-    tiles_tex: Texture,
 }
 
 impl CoreRenderer {
-    pub fn new(r: &RenderBuffer, sprites_tex: Texture, tiles_tex: Texture) -> CoreRenderer {
+    pub fn new(sprites_tex: Texture) -> CoreRenderer {
         let mut vbo = 0;
         unsafe {
             gl::GenBuffers(1, &mut vbo);
             gl::BindBuffer(gl::ARRAY_BUFFER, vbo);
         }
-        CoreRenderer {
-            vbo, sprites_tex, tiles_tex,
-            sprite_program: SpriteProgram::new(),
-            tiled_program: TiledProgram::new(r.dims.tiled_fbo_dims),
-            from_tiled_program: FromTiledProgram::new(),
-        }
+        CoreRenderer { vbo, sprites_tex, sprite_program: SpriteProgram::new() }
     }
 }
 
@@ -97,72 +85,6 @@ impl CoreRenderer {
         }
         r.vbo_data.clear();
     }
-
-    pub(in renderer) fn draw_tiles_to_fbo(&mut self, r: &mut RenderBuffer) {
-        unsafe {
-            // TODO why does binding and unbinding sprite texture prevent graphical artifacts?
-            //      (artifacts only occur when resizing if tiles are drawn before any sprites)
-            self.sprites_tex.gl_bind_texture();
-            self.sprites_tex.gl_unbind_texture();
-
-            gl::BindFramebuffer(gl::FRAMEBUFFER, self.tiled_program.fbo);
-
-            gl::ClearColor(0.0, 0.0, 0.0, 0.0);
-            gl::Clear(gl::COLOR_BUFFER_BIT);
-
-            gl::UseProgram(self.tiled_program.handle);
-            gl::Viewport(0, 0, self.tiled_program.fbo_tex_dims.0 as GLint, self.tiled_program.fbo_tex_dims.1 as GLint);
-
-            gl::ActiveTexture(gl::TEXTURE0);
-            self.tiles_tex.gl_bind_texture();
-            gl::Uniform1i(self.tiled_program.uniform_tex, 0);
-
-            gl::BindVertexArray(self.tiled_program.vao);
-
-            gl::BufferData(gl::ARRAY_BUFFER,
-                           (mem::size_of::<GLfloat>() * r.vbo_data.len()) as GLsizeiptr,
-                           mem::transmute(&r.vbo_data[0]),
-                           gl::STREAM_DRAW);
-
-            gl::DrawArrays(gl::TRIANGLES, 0, r.vbo_data.len() as GLint / 4);
-
-            gl::BindVertexArray(0);
-            self.tiles_tex.gl_unbind_texture();
-            gl::UseProgram(0);
-        }
-    }
-
-    pub(in renderer) fn draw_tiles_from_fbo(&mut self, r: &mut RenderBuffer) {
-        unsafe {
-            gl::BindFramebuffer(gl::FRAMEBUFFER, 0);
-            gl::Enable(gl::SCISSOR_TEST);
-
-            gl::UseProgram(self.from_tiled_program.handle);
-
-            gl::Viewport(0, 0, r.dims.full_screen_dims.0 as GLint, r.dims.full_screen_dims.1 as GLint);
-
-            gl::ActiveTexture(gl::TEXTURE0);
-            gl::BindTexture(gl::TEXTURE_2D, self.tiled_program.fbo_tex);
-            gl::Uniform1i(self.from_tiled_program.uniform_tex, 0); // binds to GL_TEXTURE0
-            gl::Uniform2f(self.from_tiled_program.uniform_inv_tex_dims,
-                          1. / self.tiled_program.fbo_tex_dims.0 as f32, 1. / self.tiled_program.fbo_tex_dims.1 as f32);
-            gl::Uniform1f(self.from_tiled_program.uniform_inv_tex_sample_dim, r.dims.app_pixel_scalar as f32);
-
-            gl::BindVertexArray(self.from_tiled_program.vao);
-
-            gl::BufferData(gl::ARRAY_BUFFER,
-                           (mem::size_of::<GLfloat>() * r.vbo_data.len()) as GLsizeiptr,
-                           mem::transmute(&r.vbo_data[0]),
-                           gl::STREAM_DRAW);
-
-            gl::DrawArrays(gl::TRIANGLES, 0, r.vbo_data.len() as GLint / 4);
-
-            gl::BindVertexArray(0);
-            gl::BindTexture(gl::TEXTURE_2D, 0);
-            gl::UseProgram(0);
-            gl::Disable(gl::SCISSOR_TEST);
-        }
-    }
 }
 
 impl Drop for CoreRenderer {
diff --git a/gate/src/renderer/core_renderer/sdl/tiled_program.rs b/gate/src/renderer/core_renderer/sdl/tiled_program.rs
deleted file mode 100644
index 3739943..0000000
--- a/gate/src/renderer/core_renderer/sdl/tiled_program.rs
+++ /dev/null
@@ -1,119 +0,0 @@
-// Copyright 2017-2018 Matthew D. Michelotti
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::{ptr, str, mem};
-use std::os::raw::{c_void, c_char};
-
-use gl::types::*;
-use gl;
-
-use super::shader_util;
-use renderer::shaders;
-
-pub struct TiledProgram {
-    pub handle: GLuint,
-    pub vao: GLuint,
-    vs: GLuint,
-    fs: GLuint,
-    pub uniform_tex: GLint,
-    pub fbo: GLuint,
-    pub fbo_tex: GLuint,
-    pub fbo_tex_dims: (u32, u32),
-}
-
-impl TiledProgram {
-    pub fn new(fbo_tex_dims: (u32, u32)) -> TiledProgram {
-        let vs = shader_util::compile_shader(shaders::VS_TILED_SRC, gl::VERTEX_SHADER);
-        let fs = shader_util::compile_shader(shaders::FS_TILED_SRC, gl::FRAGMENT_SHADER);
-        let handle = shader_util::link_program(vs, fs);
-        let vao = TiledProgram::make_vao(handle);
-        let (fbo, fbo_tex) = TiledProgram::make_fbo_and_tex(fbo_tex_dims);
-        unsafe {
-            TiledProgram {
-                handle, vao, vs, fs, fbo, fbo_tex, fbo_tex_dims,
-                uniform_tex: gl::GetUniformLocation(handle, c_str!("tex")),
-            }
-        }
-    }
-
-    fn make_vao(program_handle: GLuint) -> GLuint {
-        let mut vao = 0;
-        unsafe {
-            let attrib_vert = gl::GetAttribLocation(program_handle, c_str!("vert"));
-            let attrib_vs_tex_vert = gl::GetAttribLocation(program_handle, c_str!("vs_tex_vert"));
-
-            gl::GenVertexArrays(1, &mut vao);
-            gl::BindVertexArray(vao);
-
-            // TODO be consistent with the gl::TRUE/FALSE values in gl::VertexAttribPointer...
-
-            gl::EnableVertexAttribArray(attrib_vert as GLuint);
-            gl::VertexAttribPointer(attrib_vert as GLuint, 2, gl::FLOAT, gl::FALSE, 4*mem::size_of::<GLfloat>() as i32, ptr::null());
-
-            gl::EnableVertexAttribArray(attrib_vs_tex_vert as GLuint);
-            gl::VertexAttribPointer(attrib_vs_tex_vert as GLuint, 2, gl::FLOAT, gl::TRUE, 4*mem::size_of::<GLfloat>() as i32,
-                                    (2 * mem::size_of::<GLfloat>()) as *const c_void);
-
-            gl::BindVertexArray(0);
-        }
-        vao
-    }
-
-    fn make_fbo_and_tex(tex_dims: (u32, u32)) -> (GLuint, GLuint) {
-        let mut fbo = 0;
-        let mut fbo_tex = 0;
-        unsafe {
-            gl::GenFramebuffers(1, &mut fbo);
-            gl::BindFramebuffer(gl::FRAMEBUFFER, fbo);
-
-            gl::GenTextures(1, &mut fbo_tex);
-
-            gl::BindTexture(gl::TEXTURE_2D, fbo_tex);
-
-            gl::TexImage2D(gl::TEXTURE_2D, 0, gl::RGBA as GLint, tex_dims.0 as GLint, tex_dims.1 as GLint,
-                           0, gl::RGBA, gl::UNSIGNED_BYTE, ptr::null());
-
-            gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::LINEAR as GLint);
-            gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::LINEAR as GLint);
-
-            gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_WRAP_S, gl::CLAMP_TO_EDGE as GLint);
-            gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_WRAP_T, gl::CLAMP_TO_EDGE as GLint);
-
-            gl::BindTexture(gl::TEXTURE_2D, 0);
-
-            gl::FramebufferTexture2D(gl::FRAMEBUFFER, gl::COLOR_ATTACHMENT0, gl::TEXTURE_2D, fbo_tex, 0);
-
-            let draw_buffers = [gl::COLOR_ATTACHMENT0];
-            gl::DrawBuffers(1, &draw_buffers as *const GLuint);
-
-            assert!(gl::CheckFramebufferStatus(gl::FRAMEBUFFER) == gl::FRAMEBUFFER_COMPLETE);
-
-            gl::BindFramebuffer(gl::FRAMEBUFFER, 0);
-        }
-        (fbo, fbo_tex)
-    }
-}
-
-impl Drop for TiledProgram {
-    fn drop(&mut self) {
-        unsafe {
-            gl::DeleteProgram(self.handle);
-            gl::DeleteShader(self.fs);
-            gl::DeleteShader(self.vs);
-            gl::DeleteVertexArrays(1, &self.vao);
-            gl::DeleteTextures(1, &self.fbo_tex);
-            gl::DeleteFramebuffers(1, &self.fbo);
-        }
-    }
-}
diff --git a/gate/src/renderer/core_renderer/wasm.rs b/gate/src/renderer/core_renderer/wasm.rs
index e169324..cf4d9e5 100644
--- a/gate/src/renderer/core_renderer/wasm.rs
+++ b/gate/src/renderer/core_renderer/wasm.rs
@@ -21,10 +21,7 @@ use ::wasm_imports::*;
 pub struct CoreRenderer { }
 
 impl CoreRenderer {
-    pub fn new(r: &RenderBuffer) -> CoreRenderer {
-        unsafe {
-            gateWasmSetTiledFboDims(r.dims.tiled_fbo_dims.0 as c_int, r.dims.tiled_fbo_dims.1 as c_int);
-        }
+    pub fn new() -> CoreRenderer {
         CoreRenderer { }
     }
 }
@@ -47,16 +44,4 @@ impl CoreRenderer {
             gateWasmDrawSprites(mem::size_of::<f32>() * r.vbo_data.len(), mem::transmute(&r.vbo_data[0]));
         }
     }
-
-    pub(in renderer) fn draw_tiles_to_fbo(&mut self, r: &mut RenderBuffer) {
-        unsafe {
-            gateWasmDrawTilesToFbo(mem::size_of::<f32>() * r.vbo_data.len(), mem::transmute(&r.vbo_data[0]));
-        }
-    }
-
-    pub(in renderer) fn draw_tiles_from_fbo(&mut self, r: &mut RenderBuffer) {
-        unsafe {
-            gateWasmDrawTilesFromFbo(mem::size_of::<f32>() * r.vbo_data.len(), mem::transmute(&r.vbo_data[0]), r.dims.app_pixel_scalar as f32);
-        }
-    }
 }
diff --git a/gate/src/renderer/geom.rs b/gate/src/renderer/geom.rs
index b9c1cda..0f0e478 100644
--- a/gate/src/renderer/geom.rs
+++ b/gate/src/renderer/geom.rs
@@ -22,7 +22,6 @@ impl Vec2 {
     pub fn new(x: f64, y: f64) -> Vec2 { Vec2 { x, y } }
     pub fn zero() -> Vec2 { Vec2::new(0.0, 0.0) }
     pub fn len(&self) -> f64 { (self.x * self.x + self.y * self.y).sqrt() }
-    pub fn is_int_aligned(&self) -> bool { self.x.fract() == 0.0 && self.y.fract() == 0.0 }
 }
 
 impl Add<Vec2> for Vec2 {
@@ -67,11 +66,6 @@ impl Mat2 {
 
     pub fn col_0(&self) -> Vec2 { Vec2::new(self.a, self.c) }
     pub fn col_1(&self) -> Vec2 { Vec2::new(self.b, self.d) }
-
-    fn is_int_aligned(&self) -> bool {
-        (self.a == 0.0 && self.d == 0.0 && self.b.fract() == 0.0 && self.c.fract() == 0.0) ||
-            (self.b == 0.0 && self.c == 0.0 && self.a.fract() == 0.0 && self.d.fract() == 0.0)
-    }
 }
 
 impl Mul<Vec2> for Mat2 {
@@ -230,8 +224,4 @@ impl Affine {
     }
 
     pub(crate) fn mat(&self) -> &Mat2 { &self.mat }
-
-    pub(crate) fn is_int_aligned(&self) -> bool {
-        self.offset.is_int_aligned() && self.mat.is_int_aligned()
-    }
 }
diff --git a/gate/src/renderer/render_buffer.rs b/gate/src/renderer/render_buffer.rs
index af3e759..2b4e042 100644
--- a/gate/src/renderer/render_buffer.rs
+++ b/gate/src/renderer/render_buffer.rs
@@ -20,16 +20,7 @@ use super::atlas::Atlas;
 use super::geom::Affine;
 
 #[derive(PartialEq, Copy, Clone)]
-pub(super) enum Mode { Sprite, Tiled((f64, f64)) }
-
-impl Mode {
-    pub fn tiled_camera(self) -> (f64, f64) {
-        match self {
-            Mode::Tiled(camera) => camera,
-            _ => panic!("not in tiled mode"),
-        }
-    }
-}
+pub(super) enum Mode { Sprite }
 
 pub(super) struct RenderDims {
     pub min_aspect_ratio: f64,
@@ -86,17 +77,15 @@ fn to_fbo_dim(app_dim: f64) -> u32 {
 
 pub struct RenderBuffer {
     pub(super) sprite_atlas: Atlas,
-    pub(super) tiled_atlas: Atlas,
     pub(super) mode: Mode,
     pub(super) vbo_data: Vec<f32>,
     pub(super) dims: RenderDims,
 }
 
 impl RenderBuffer {
-    pub fn new(info: &AppInfo, screen_dims: (u32, u32), sprite_atlas: Atlas, tiled_atlas: Atlas) -> RenderBuffer {
+    pub fn new(info: &AppInfo, screen_dims: (u32, u32), sprite_atlas: Atlas) -> RenderBuffer {
         RenderBuffer {
             sprite_atlas,
-            tiled_atlas,
             mode: Mode::Sprite,
             vbo_data: Vec::new(),
             dims: RenderDims::new(info.min_aspect_ratio, info.max_aspect_ratio, info.app_height, screen_dims),
@@ -114,12 +103,6 @@ impl RenderBuffer {
         if !self.vbo_data.is_empty() {
             match self.mode {
                 Mode::Sprite => r.draw_sprites(self),
-                Mode::Tiled(_) => {
-                    r.draw_tiles_to_fbo(self);
-                    self.vbo_data.clear();
-                    vbo_packer::append_tile_fbo(self);
-                    r.draw_tiles_from_fbo(self);
-                },
             }
             self.vbo_data.clear();
         }
@@ -129,9 +112,4 @@ impl RenderBuffer {
         self.change_mode(r, Mode::Sprite);
         vbo_packer::append_sprite(self, affine, sprite_id, flash_ratio);
     }
-
-    pub(super) fn append_tile(&mut self, r: &mut CoreRenderer, camera: (f64, f64), affine: &Affine, tile_id: u16) {
-        self.change_mode(r, Mode::Tiled(camera));
-        vbo_packer::append_tile(self, affine, tile_id);
-    }
 }
diff --git a/gate/src/renderer/renderer.rs b/gate/src/renderer/renderer.rs
index d1e79a0..4e58f51 100644
--- a/gate/src/renderer/renderer.rs
+++ b/gate/src/renderer/renderer.rs
@@ -55,16 +55,6 @@ impl<A: AppAssetId> Renderer<A> {
         SpriteRenderer { r: self }
     }
 
-    /// Enters "tiled mode", for rendering tiles that must line up without any seams.
-    ///
-    /// `camera_x` and `camera_y` specify the location of the center of the screen
-    /// relative to the `TiledRenderer` coordinate system origin.
-    /// This may be important to specify if a fractional offset is needed,
-    /// because an `Affine` used in `TiledRenderer` must have integer offsets.
-    pub fn tiled_mode(&mut self, camera_x: f64, camera_y: f64) -> TiledRenderer<A> {
-        TiledRenderer { r: self, camera: (camera_x, camera_y) }
-    }
-
     pub(crate) fn app_dims(&self) -> (f64, f64) { self.b.dims.app_dims }
 
     pub(crate) fn to_app_pos(&self, raw_x: i32, raw_y: i32) -> (f64, f64) {
@@ -111,23 +101,3 @@ impl<'a, A: AppAssetId + 'a> SpriteRenderer<'a, A> {
         self.r.b.append_sprite(&mut self.r.c, affine, sprite.id_u16(), flash_ratio);
     }
 }
-
-/// A rendering mode for tiles that must line up without any seams.
-pub struct TiledRenderer<'a, A: AppAssetId + 'a> {
-    camera: (f64, f64),
-    r: &'a mut Renderer<A>,
-}
-
-impl<'a, A: AppAssetId + 'a> TiledRenderer<'a, A> {
-    /// Draws the given `tile` using the given `affine` transformation from the origin.
-    ///
-    /// The `affine` transformation must be such that the pixels of the `tile` line up with
-    /// the "app pixels" of the `TiledRenderer` exactly.
-    /// For example, if the `tile` has an anchor on the intersection of pixel boundaries,
-    /// then the `affine` should only use integer translation and scaling (not fractional),
-    /// and should only use rotations that are multiples of 90 degrees.
-    /// Will panic if this is not the case.
-    pub fn draw(&mut self, affine: &Affine, tile: A::Tile) {
-        self.r.b.append_tile(&mut self.r.c, self.camera, affine, tile.id_u16());
-    }
-}
diff --git a/gate/src/renderer/shaders/from_tiled.frag b/gate/src/renderer/shaders/from_tiled.frag
deleted file mode 100644
index 895d8dd..0000000
--- a/gate/src/renderer/shaders/from_tiled.frag
+++ /dev/null
@@ -1,29 +0,0 @@
-#version 100
-
-// Copyright 2017-2018 Matthew D. Michelotti
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-precision highp float;
-
-uniform sampler2D tex;
-uniform vec2 inv_tex_dims; // inverse of tex dimensions
-uniform float inv_tex_sample_dim; // inverse width-height of sampling region, in tex pixels
-
-varying vec2 fs_tex_vert_rb; // right-bottom vertex of sampling region, in tex pixels
-
-void main() {
-    vec2 mid = floor(fs_tex_vert_rb);
-    vec2 sample_coords = mid - 0.5 + min((fs_tex_vert_rb - mid) * inv_tex_sample_dim, 1.0);
-    gl_FragColor = texture2D(tex, sample_coords * inv_tex_dims);
-}
diff --git a/gate/src/renderer/shaders/from_tiled.vert b/gate/src/renderer/shaders/from_tiled.vert
deleted file mode 100644
index 89a3dc9..0000000
--- a/gate/src/renderer/shaders/from_tiled.vert
+++ /dev/null
@@ -1,25 +0,0 @@
-#version 100
-
-// Copyright 2017-2018 Matthew D. Michelotti
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-attribute vec2 vert;
-attribute vec2 vs_tex_vert_rb;
-
-varying vec2 fs_tex_vert_rb;
-
-void main() {
-    fs_tex_vert_rb = vs_tex_vert_rb;
-    gl_Position = vec4(vert, 0, 1);
-}
diff --git a/gate/src/renderer/shaders/mod.rs b/gate/src/renderer/shaders/mod.rs
index ee63c68..9ee8c54 100644
--- a/gate/src/renderer/shaders/mod.rs
+++ b/gate/src/renderer/shaders/mod.rs
@@ -16,9 +16,3 @@ use std::os::raw::c_char;
 
 pub const VS_SPRITE_SRC: *const c_char = include_c_str!("sprite.vert");
 pub const FS_SPRITE_SRC: *const c_char = include_c_str!("sprite.frag");
-
-pub const VS_TILED_SRC: *const c_char = include_c_str!("tiled.vert");
-pub const FS_TILED_SRC: *const c_char = include_c_str!("tiled.frag");
-
-pub const VS_FROM_TILED_SRC: *const c_char = include_c_str!("from_tiled.vert");
-pub const FS_FROM_TILED_SRC: *const c_char = include_c_str!("from_tiled.frag");
diff --git a/gate/src/renderer/shaders/tiled.frag b/gate/src/renderer/shaders/tiled.frag
deleted file mode 100644
index 8df676e..0000000
--- a/gate/src/renderer/shaders/tiled.frag
+++ /dev/null
@@ -1,24 +0,0 @@
-#version 100
-
-// Copyright 2017-2018 Matthew D. Michelotti
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-precision highp float;
-
-uniform sampler2D tex;
-varying vec2 fs_tex_vert;
-
-void main() {
-    gl_FragColor = texture2D(tex, fs_tex_vert);
-}
diff --git a/gate/src/renderer/shaders/tiled.vert b/gate/src/renderer/shaders/tiled.vert
deleted file mode 100644
index 35fa2fc..0000000
--- a/gate/src/renderer/shaders/tiled.vert
+++ /dev/null
@@ -1,25 +0,0 @@
-#version 100
-
-// Copyright 2017-2018 Matthew D. Michelotti
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-attribute vec2 vert;
-attribute vec2 vs_tex_vert;
-
-varying vec2 fs_tex_vert;
-
-void main() {
-    fs_tex_vert = vs_tex_vert;
-    gl_Position = vec4(vert, 0, 1);
-}
diff --git a/gate/src/renderer/vbo_packer.rs b/gate/src/renderer/vbo_packer.rs
index fa09077..1ef7e68 100644
--- a/gate/src/renderer/vbo_packer.rs
+++ b/gate/src/renderer/vbo_packer.rs
@@ -61,96 +61,3 @@ fn add_sprite_vertex(vbo_data: &mut Vec<f32>, pad: (f32, f32), flash_ratio: f32,
     vbo_data.push(src.1 + pad.1);
     vbo_data.push(flash_ratio);
 }
-
-pub fn append_tile(r: &mut RenderBuffer, affine: &Affine, tile_id: u16) {
-    let camera = r.mode.tiled_camera();
-
-    let img_coords = r.tiled_atlas.images[&tile_id];
-    assert!(affine.pre_translate(img_coords.anchor.0 as f64, img_coords.anchor.1 as f64).is_int_aligned(),
-            "affine transformation must exactly line up with pixels for tiled rendering");
-
-    let inv_tex_dims = (1.0 / r.tiled_atlas.dims.0, 1.0 / r.tiled_atlas.dims.1);
-
-    let lt = (img_coords.lt.0 * inv_tex_dims.0, img_coords.lt.1 * inv_tex_dims.1);
-    let rb = (img_coords.rb.0 * inv_tex_dims.0, img_coords.rb.1 * inv_tex_dims.1);
-    let lb = (lt.0, rb.1);
-    let rt = (rb.0, lt.1);
-
-    let dst_lt = (img_coords.lt.0 - img_coords.anchor.0, -(img_coords.lt.1 - img_coords.anchor.1));
-    let dst_rb = (img_coords.rb.0 - img_coords.anchor.0, -(img_coords.rb.1 - img_coords.anchor.1));
-    let dst_lb = (dst_lt.0, dst_rb.1);
-    let dst_rt = (dst_rb.0, dst_lt.1);
-
-    let fbo_camera = fbo_camera(camera, r.dims.tiled_fbo_dims);
-    let affine = affine.post_translate(fbo_camera.0 - camera.0, fbo_camera.1 - camera.1)
-                       .post_scale_axes(2.0 / r.dims.tiled_fbo_dims.0 as f64,
-                                        2.0 / r.dims.tiled_fbo_dims.1 as f64);
-    let aff_lt = affine.apply_f32(dst_lt);
-    let aff_rb = affine.apply_f32(dst_rb);
-    let aff_lb = affine.apply_f32(dst_lb);
-    let aff_rt = affine.apply_f32(dst_rt);
-
-    let vbo_data = &mut r.vbo_data;
-    add_tile_vertex(vbo_data, lt, aff_lt);
-    add_tile_vertex(vbo_data, rt, aff_rt);
-    add_tile_vertex(vbo_data, lb, aff_lb);
-    add_tile_vertex(vbo_data, rt, aff_rt);
-    add_tile_vertex(vbo_data, lb, aff_lb);
-    add_tile_vertex(vbo_data, rb, aff_rb);
-}
-
-fn add_tile_vertex(vbo_data: &mut Vec<f32>, src: (f32, f32), dst: (f32, f32)) {
-    vbo_data.push(dst.0);
-    vbo_data.push(dst.1);
-    vbo_data.push(src.0);
-    vbo_data.push(src.1);
-}
-
-fn fbo_camera(camera: (f64, f64), fbo_tex_dims: (u32, u32)) -> (f64, f64) {
-    (fbo_camera_coord(camera.0, fbo_tex_dims.0), fbo_camera_coord(camera.1, fbo_tex_dims.1))
-}
-
-fn fbo_camera_coord(mut camera: f64, fbo_dim: u32) -> f64 {
-    if fbo_dim % 2 == 1 {
-        camera += 0.5;
-    }
-    camera = camera.fract();
-    if camera > 0.5 {
-        camera -= 1.0
-    } else if camera < -0.5 {
-        camera += 1.0
-    }
-    camera
-}
-
-pub fn append_tile_fbo(r: &mut RenderBuffer) {
-    let camera = r.mode.tiled_camera();
-
-    let pad = 0.5 / r.dims.app_pixel_scalar as f32;
-    let camera = fbo_camera(camera, r.dims.tiled_fbo_dims);
-    let camera = (0.5 * r.dims.tiled_fbo_dims.0 as f32 + camera.0 as f32,
-                  0.5 * r.dims.tiled_fbo_dims.1 as f32 + camera.1 as f32);
-    let half_dims = (r.dims.app_dims.0 as f32 * 0.5, r.dims.app_dims.1 as f32 * 0.5);
-    let lb = (camera.0 - half_dims.0, camera.1 - half_dims.1);
-    let rt = (camera.0 + half_dims.0, camera.1 + half_dims.1);
-    let lt = (lb.0, rt.1);
-    let rb = (rt.0, lb.1);
-
-    let w_ratio = r.dims.used_screen_dims.0 as f32 / r.dims.full_screen_dims.0 as f32;
-    let h_ratio = r.dims.used_screen_dims.1 as f32 / r.dims.full_screen_dims.1 as f32;
-
-    let vbo_data = &mut r.vbo_data;
-    add_from_tiled_vertex(vbo_data, pad, lb, (-w_ratio, -h_ratio));
-    add_from_tiled_vertex(vbo_data, pad, rb, ( w_ratio, -h_ratio));
-    add_from_tiled_vertex(vbo_data, pad, lt, (-w_ratio,  h_ratio));
-    add_from_tiled_vertex(vbo_data, pad, rb, ( w_ratio, -h_ratio));
-    add_from_tiled_vertex(vbo_data, pad, lt, (-w_ratio,  h_ratio));
-    add_from_tiled_vertex(vbo_data, pad, rt, ( w_ratio,  h_ratio));
-}
-
-fn add_from_tiled_vertex(vbo_data: &mut Vec<f32>, pad: f32, src: (f32, f32), dst: (f32, f32)) {
-    vbo_data.push(dst.0);
-    vbo_data.push(dst.1);
-    vbo_data.push(src.0 + pad);
-    vbo_data.push(src.1 + pad);
-}
diff --git a/gate_build/src/asset_id.template.rs b/gate_build/src/asset_id.template.rs
index b37a033..38369ab 100644
--- a/gate_build/src/asset_id.template.rs
+++ b/gate_build/src/asset_id.template.rs
@@ -19,7 +19,6 @@ pub struct AssetId;
 
 impl AppAssetId for AssetId {{
     type Sprite = SpriteId;
-    type Tile = TileId;
     type Music = MusicId;
     type Sound = SoundId;
 }}
@@ -30,5 +29,3 @@ impl AppAssetId for AssetId {{
 {}
 
 {}
-
-{}
diff --git a/gate_build/src/asset_packer.rs b/gate_build/src/asset_packer.rs
index 442f5fc..7aa9173 100644
--- a/gate_build/src/asset_packer.rs
+++ b/gate_build/src/asset_packer.rs
@@ -33,7 +33,6 @@ pub struct AssetPacker {
     assets_dir: PathBuf,
     check_rerun: bool,
     sprites: Option<Vec<String>>,
-    tiles: Option<Vec<String>>,
     music: Option<Vec<String>>,
     sounds: Option<Vec<String>>,
     js: bool,
@@ -51,7 +50,6 @@ impl AssetPacker {
         AssetPacker {
             assets_dir: assets_dir.to_path_buf(),
             sprites: None,
-            tiles: None,
             check_rerun: false,
             music: None,
             sounds: None,
@@ -67,7 +65,7 @@ impl AssetPacker {
     ///
     /// Panics if called after calling methods to pack assets.
     pub fn cargo_rerun_if_changed(&mut self) {
-        assert!(self.sprites.is_none() && self.tiles.is_none(), "cannot add rerun checks after asset packing has already started");
+        assert!(self.sprites.is_none(), "cannot add rerun checks after asset packing has already started");
         self.check_rerun = true;
     }
 
@@ -100,21 +98,6 @@ impl AssetPacker {
         self.sprites.as_ref().unwrap()
     }
 
-    /// Packs tile images into an atlas, to be rendered by Gate renderer in "tiled" mode.
-    ///
-    /// Follows the same packing conventions as `self.sprites(in_dir)`.
-    /// See that method for more details.
-    ///
-    /// Note: in the current implementation of `gate` there is only one atlas for tiles,
-    /// but in the future there are plans to allow for larger games that may need
-    /// multiple atlases loaded at different times.
-    pub fn tiles(&mut self, in_dir: &Path) -> &[String] {
-        assert!(self.tiles.is_none(), "self.tiles(...) was already invoked");
-        let output = &self.assets_dir.join("tiles");
-        self.tiles = Some(form_atlas(in_dir, output, 0, self.check_rerun));
-        self.tiles.as_ref().unwrap()
-    }
-
     /// Creates handles for and moves music files from `in_dir` to the assets directory.
     ///
     /// Music files are expected to be in `.ogg` format,
@@ -187,12 +170,10 @@ impl AssetPacker {
 
     fn gen_asset_id_code_checked(self, out: &Path) -> io::Result<()> {
         let sprites_enum = gen_asset_enum("SpriteId", &self.sprites.expect("self.sprites(...) was not invoked"));
-        let tiles_enum = gen_asset_enum("TileId", &self.tiles.expect("self.tiles(...) was not invoked"));
         let music_enum = gen_asset_enum("MusicId", &self.music.unwrap_or(vec![]));
         let sounds_enum = gen_asset_enum("SoundId", &self.sounds.unwrap_or(vec![]));
 
-        let code = format!(include_str!("asset_id.template.rs"),
-                           sprites_enum, tiles_enum, music_enum, sounds_enum);
+        let code = format!(include_str!("asset_id.template.rs"), sprites_enum, music_enum, sounds_enum);
         if let Some(out_dir) = out.parent() {
             fs::create_dir_all(out_dir)?;
         }
diff --git a/gate_build/src/html/gate.js b/gate_build/src/html/gate.js
index 0e21512..0e9c98b 100644
--- a/gate_build/src/html/gate.js
+++ b/gate_build/src/html/gate.js
@@ -65,16 +65,6 @@ function setSpriteAttribPointers () {
   gl.vertexAttribPointer(Module.spriteProg.attribs.vsFlashRatio, 1, gl.FLOAT, false, 7 * floatSize, 6 * floatSize);
 }
 
-function setTiledAttribPointers () {
-  gl.vertexAttribPointer(Module.tiledProg.attribs.vert, 2, gl.FLOAT, false, 4 * floatSize, 0);
-  gl.vertexAttribPointer(Module.tiledProg.attribs.vsTexVert, 2, gl.FLOAT, false, 4 * floatSize, 2 * floatSize);
-}
-
-function setFromTiledAttribPointers () {
-  gl.vertexAttribPointer(Module.fromTiledProg.attribs.vert, 2, gl.FLOAT, false, 4 * floatSize, 0);
-  gl.vertexAttribPointer(Module.fromTiledProg.attribs.vsTexVertRb, 2, gl.FLOAT, false, 4 * floatSize, 2 * floatSize);
-}
-
 const imports = {
   env: {
     gateWasmSetScissor: function (x, y, w, h) {
@@ -102,72 +92,6 @@ const imports = {
       gl.drawArrays(gl.TRIANGLES, 0, size / 28);
       gl.disable(gl.SCISSOR_TEST);
     },
-    gateWasmSetTiledFboDims: function (w, h) {
-      Module.tiledFboTexW = w;
-      Module.tiledFboTexH = h;
-
-      Module.tiledFbo = gl.createFramebuffer();
-      gl.bindFramebuffer(gl.FRAMEBUFFER, Module.tiledFbo);
-
-      Module.tiledFboTex = gl.createTexture();
-
-      gl.bindTexture(gl.TEXTURE_2D, Module.tiledFboTex);
-      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, tilesImage);
-      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, w, h, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
-      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-
-      gl.bindTexture(gl.TEXTURE_2D, null);
-
-      gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, Module.tiledFboTex, 0);
-      if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) != gl.FRAMEBUFFER_COMPLETE) {
-        throw "error building framebuffer";
-      }
-
-      gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-    },
-    gateWasmDrawTilesToFbo: function (size, dataPtr) {
-      gl.bindFramebuffer(gl.FRAMEBUFFER, Module.tiledFbo);
-
-      gl.clearColor(0.0, 0.0, 0.0, 0.0);
-      gl.clear(gl.COLOR_BUFFER_BIT);
-
-      gl.useProgram(Module.tiledProg.prog);
-      gl.viewport(0, 0, Module.tiledFboTexW, Module.tiledFboTexH);
-
-      gl.activeTexture(gl.TEXTURE0);
-      gl.bindTexture(gl.TEXTURE_2D, Module.tiledTex);
-      gl.uniform1i(Module.tiledProg.uniformTex, 0);
-
-      setTiledAttribPointers();
-
-      gl.bufferData(gl.ARRAY_BUFFER, new Uint8Array(Module.memory.buffer, dataPtr, size), gl.STREAM_DRAW);
-
-      gl.drawArrays(gl.TRIANGLES, 0, size / 16);
-    },
-    gateWasmDrawTilesFromFbo: function (size, dataPtr, appPixelScalar) {
-      gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-      gl.enable(gl.SCISSOR_TEST);
-
-      gl.useProgram(Module.fromTiledProg.prog);
-
-      gl.viewport(0, 0, canvas.width, canvas.height);
-
-      gl.activeTexture(gl.TEXTURE0);
-      gl.bindTexture(gl.TEXTURE_2D, Module.tiledFboTex);
-      gl.uniform1i(Module.fromTiledProg.uniformTex, 0);
-      gl.uniform2f(Module.fromTiledProg.uniformInvTexDims, 1.0 / Module.tiledFboTexW, 1.0 / Module.tiledFboTexH);
-      gl.uniform1f(Module.fromTiledProg.uniformInvTexSampleDim, appPixelScalar);
-
-      setFromTiledAttribPointers();
-
-      gl.bufferData(gl.ARRAY_BUFFER, new Uint8Array(Module.memory.buffer, dataPtr, size), gl.STREAM_DRAW);
-
-      gl.drawArrays(gl.TRIANGLES, 0, size / 16);
-      gl.disable(gl.SCISSOR_TEST);
-    },
     gateWasmLoopMusic: function (id) {
       if (Module.currentMusic != null) {
         Module.currentMusic.stop();
@@ -184,12 +108,6 @@ const imports = {
     gateWasmPlaySound: function (id) {
       Module.sounds[id].play();
     },
-    gateWasmTiledAtlasBinSize: function () {
-      return Module.tiledAtlas.length;
-    },
-    gateWasmTiledAtlasBinFill: function(bufferPtr) {
-      new Uint8Array(Module.memory.buffer).set(Module.tiledAtlas, bufferPtr);
-    },
     gateWasmSpriteAtlasBinSize: function () {
       return Module.spriteAtlas.length;
     },
@@ -212,13 +130,6 @@ fetch("sprites.atlas").then(response =>
   tryStart();
 });
 
-fetch("tiles.atlas").then(response =>
-  response.arrayBuffer()
-).then(bytes => {
-  Module.tiledAtlas = new Uint8Array(bytes);
-  tryStart();
-});
-
 const spriteImage = new Image();
 spriteImage.onload = function () {
   Module.spriteTexWidth = spriteImage.width;
@@ -232,17 +143,6 @@ spriteImage.onload = function () {
 };
 spriteImage.src = "sprites.png";
 
-const tilesImage = new Image();
-tilesImage.onload = function () {
-  Module.tiledTex = gl.createTexture();
-  gl.bindTexture(gl.TEXTURE_2D, Module.tiledTex);
-  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, tilesImage);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
-  tryStart();
-};
-tilesImage.src = "tiles.png";
-
 fetch("gate_app.wasm").then(response =>
   response.arrayBuffer()
 ).then(bytes =>
@@ -261,10 +161,6 @@ fetch("gate_app.wasm").then(response =>
   Module.gateWasmSoundCount = mod.exports.gateWasmSoundCount;
   Module.gateWasmSpriteVertSrc = mod.exports.gateWasmSpriteVertSrc;
   Module.gateWasmSpriteFragSrc = mod.exports.gateWasmSpriteFragSrc;
-  Module.gateWasmTiledVertSrc = mod.exports.gateWasmTiledVertSrc;
-  Module.gateWasmTiledFragSrc = mod.exports.gateWasmTiledFragSrc;
-  Module.gateWasmFromTiledVertSrc = mod.exports.gateWasmFromTiledVertSrc;
-  Module.gateWasmFromTiledFragSrc = mod.exports.gateWasmFromTiledFragSrc;
   tryStart();
 });
 
@@ -321,54 +217,6 @@ function initSpriteProg () {
   };
 }
 
-function makeTiledAttribs (tiledProg) {
-  const attribs = {
-    vert: gl.getAttribLocation(tiledProg, "vert"),
-    vsTexVert: gl.getAttribLocation(tiledProg, "vs_tex_vert"),
-  };
-
-  gl.enableVertexAttribArray(attribs.vert);
-  gl.enableVertexAttribArray(attribs.vsTexVert);
-
-  return attribs;
-}
-
-function initTiledProg () {
-  Module.tiledVert = loadShader(gl.VERTEX_SHADER, readCStr(Module.gateWasmTiledVertSrc()));
-  Module.tiledFrag = loadShader(gl.FRAGMENT_SHADER, readCStr(Module.gateWasmTiledFragSrc()));
-  const prog = linkShaderProgram(Module.tiledVert, Module.tiledFrag);
-  Module.tiledProg = {
-    prog: prog,
-    attribs: makeTiledAttribs(prog),
-    uniformTex: gl.getUniformLocation(prog, "tex"),
-  };
-}
-
-function makeFromTiledAttribs (fromTiledProg) {
-  const attribs = {
-    vert: gl.getAttribLocation(fromTiledProg, "vert"),
-    vsTexVertRb: gl.getAttribLocation(fromTiledProg, "vs_tex_vert_rb"),
-  };
-
-  gl.enableVertexAttribArray(attribs.vert);
-  gl.enableVertexAttribArray(attribs.vsTexVertRb);
-
-  return attribs;
-}
-
-function initFromTiledProg () {
-  Module.fromTiledVert = loadShader(gl.VERTEX_SHADER, readCStr(Module.gateWasmFromTiledVertSrc()));
-  Module.fromTiledFrag = loadShader(gl.FRAGMENT_SHADER, readCStr(Module.gateWasmFromTiledFragSrc()));
-  const prog = linkShaderProgram(Module.fromTiledVert, Module.fromTiledFrag);
-  Module.fromTiledProg = {
-    prog: prog,
-    attribs: makeFromTiledAttribs(prog),
-    uniformTex: gl.getUniformLocation(prog, "tex"),
-    uniformInvTexDims: gl.getUniformLocation(prog, "inv_tex_dims"),
-    uniformInvTexSampleDim: gl.getUniformLocation(prog, "inv_tex_sample_dim"),
-  };
-}
-
 function initAudioArray (prefix, count, loop) {
   Module.loadingAudioCount += count;
   var result = new Array(count);
@@ -386,7 +234,7 @@ function initAudioArray (prefix, count, loop) {
 }
 
 function tryStart () {
-  if (Module.spriteAtlas && Module.tiledAtlas && Module.memory && Module.spriteTex && Module.tiledTex) {
+  if (Module.spriteAtlas && Module.memory && Module.spriteTex) {
     if (!Module.gateWasmIsAppDefined()) {
       Module.main();
       if (!Module.gateWasmIsAppDefined()) {
@@ -395,8 +243,6 @@ function tryStart () {
       }
     }
     initSpriteProg();
-    initTiledProg();
-    initFromTiledProg();
     Module.musics = initAudioArray("music", Module.gateWasmMusicCount(), true);
     Module.sounds = initAudioArray("sound", Module.gateWasmSoundCount(), false);
     tryStart2();