Texture replacement in bevy 0.3,0

texture.rs

use bevy::{
  prelude::*,
  render::texture::{Extent3d, Texture, TextureDimension, TextureFormat},
};

struct MyTimer {
  timer: Timer,
}

struct LogoHandle(Option<Handle<Texture>>);

/// This example shows various ways to configure texture materials in 3D
fn main() {
  App::build()
    .add_plugins(DefaultPlugins)
    .add_startup_system(setup.system())
    .add_resource(MyTimer {
      timer: Timer::from_seconds(1.0, false),
    })
    .add_resource(LogoHandle(None))
    .add_system(timer_system.system())
    .run();
}

fn timer_system(
  texture_handle: Res<LogoHandle>,
  time: Res<Time>,
  mut my_timer: ResMut<MyTimer>,
  mut textures: ResMut<Assets<Texture>>,
) {
  my_timer.timer.tick(time.delta_seconds);
  if my_timer.timer.just_finished {
    let texture_handle = texture_handle.0.as_ref().unwrap();
    let old_t = textures.get_mut(texture_handle).unwrap();
    *old_t = white_texture();
    println!("Replaced texture with white");
  }
}

fn white_texture() -> Texture {
  let mut rvec = vec![];
  rvec.resize((200 * 200 * 4) as usize, 255);
  Texture::new(Vec2::new(200.0, 200.0), rvec, TextureFormat::Rgba8UnormSrgb)
}

/// sets up a scene with textured entities
fn setup(
  mut commands: Commands,
  asset_server: Res<AssetServer>,
  mut meshes: ResMut<Assets<Mesh>>,
  mut materials: ResMut<Assets<StandardMaterial>>,

  mut logohandle: ResMut<LogoHandle>,
  mut textures: ResMut<Assets<Texture>>,
) {
  // load a texture and retrieve its aspect ratio
  let texture_handle = asset_server.load("branding/bevy_logo_dark_big.png");
  // let texture_handle = textures.add(white_texture());
  *logohandle = LogoHandle(Some(texture_handle.clone()));
  let aspect = 0.25;

  // create a new quad mesh. this is what we will apply the texture to
  let quad_width = 8.0;
  let quad_handle = meshes.add(Mesh::from(shape::Quad::new(Vec2::new(
    quad_width,
    quad_width * aspect,
  ))));

  // this material renders the texture normally
  let material_handle = materials.add(StandardMaterial {
    albedo_texture: Some(texture_handle.clone()),
    shaded: false,
    ..Default::default()
  });

  // this material modulates the texture to make it red (and slightly transparent)
  let red_material_handle = materials.add(StandardMaterial {
    albedo: Color::rgba(1.0, 0.0, 0.0, 0.5),
    albedo_texture: Some(texture_handle.clone()),
    shaded: false,
  });

  // and lets make this one blue! (and also slightly transparent)
  let blue_material_handle = materials.add(StandardMaterial {
    albedo: Color::rgba(0.0, 0.0, 1.0, 0.5),
    albedo_texture: Some(texture_handle),
    shaded: false,
  });

  // add entities to the world
  commands
    // textured quad - normal
    .spawn(PbrComponents {
      mesh: quad_handle.clone(),
      material: material_handle,
      transform: Transform {
        translation: Vec3::new(0.0, 0.0, 1.5),
        rotation: Quat::from_rotation_x(-std::f32::consts::PI / 5.0),
        ..Default::default()
      },
      draw: Draw {
        is_transparent: true,
        ..Default::default()
      },
      ..Default::default()
    })
    // textured quad - modulated
    .spawn(PbrComponents {
      mesh: quad_handle.clone(),
      material: red_material_handle,
      transform: Transform {
        translation: Vec3::new(0.0, 0.0, 0.0),
        rotation: Quat::from_rotation_x(-std::f32::consts::PI / 5.0),
        ..Default::default()
      },
      draw: Draw {
        is_transparent: true,
        ..Default::default()
      },
      ..Default::default()
    })
    // textured quad - modulated
    .spawn(PbrComponents {
      mesh: quad_handle,
      material: blue_material_handle,
      transform: Transform {
        translation: Vec3::new(0.0, 0.0, -1.5),
        rotation: Quat::from_rotation_x(-std::f32::consts::PI / 5.0),
        ..Default::default()
      },
      draw: Draw {
        is_transparent: true,
        ..Default::default()
      },
      ..Default::default()
    })
    // camera
    .spawn(Camera3dComponents {
      transform: Transform::from_translation(Vec3::new(3.0, 5.0, 8.0))
        .looking_at(Vec3::default(), Vec3::unit_y()),
      ..Default::default()
    });
}