Struct Sky 

pub struct Sky {

    pub atmosphere: bool,
    pub haze: f32,
    pub sun_size: f32,
    pub stars: f32,
    pub night_light: Color,
    pub fog_density: f32,
    pub fog_height: f32,
    pub fog_falloff: f32,
    pub fog_color: Color,
    pub fog_start: f32,
    pub fog_end: f32,
    pub fog_sun_glow: f32,
    pub fog_sun_focus: f32,
    pub light_shafts: f32,
}

The sky behind the 3D world, and the fog in front of it: ctx.sky.

With atmosphere on (the default), the sky is worked out from the sun in Lighting: blue by day, orange and red when the sun is low, dark with stars at night. The sun itself turns orange near the horizon and sets, and the sky’s light replaces Lighting::sky_color and ground_color. One world unit is taken to be a meter.

// Late evening, a little hazy, with fog lying in the valleys.
ctx.lighting.sun_direction = Sky::sun_direction_at(18.5);
ctx.sky.haze = 3.0;
ctx.sky.fog_density = 0.01;
ctx.sky.fog_height = 5.0;

Fields

atmosphere: bool

Draw a physical sky lit by the sun, and light the scene from it. Off: the background is the clear color and the light comes from Lighting’s colors. Default on.

haze: f32

Dust and water in the air, from 0 (none) up: more makes the sky paler, the glow around the sun bigger and sunsets redder. Default 1.

sun_size: f32

The sun’s size in the sky, in degrees across. Default 1.5 (the real sun is about 0.5, which looks small on a screen).

stars: f32

How bright the stars are at night, 0 for none. Default 1.

night_light: Color

Light at night, when the sun is down: moonlight and starlight. Default a dim blue.

fog_density: f32

How thick the fog is near the ground: the share of light it takes away per world unit. 0 (the default) is no fog; 0.002 hazes the far distance; 0.05 is thick.

fog_height: f32

The height the fog lies at: below it, it’s thickest. Default 0.

fog_falloff: f32

How quickly the fog thins out above fog_height, in world units: it halves about every 0.7 times this. Default 50.

fog_color: Color

The fog’s color without an atmosphere; with one, the fog takes the sky’s color behind it. Default a pale grey-blue.

fog_start: f32

Distance fog: none closer than fog_start world units, all fog past fog_end, and a straight blend between. It hides the far end of a big world whatever the height. Off while fog_end is not past fog_start (default 0 and 0). The sky itself takes none.

fog_end: f32

Where the distance fog hides everything. Default 0 (off).

fog_sun_glow: f32

How much sunlight the fog scatters toward the camera, so it glows when looking toward the sun: 0 (the default) none, 0.1 a soft glow.

fog_sun_focus: f32

How tight that glow is around the sun, 0 (all around) to just under 1 (a small bright halo). Default 0.7.

light_shafts: f32

Light shafts: how much shadows cut the fog’s sun glow, from 0 (the default, off) to 1. Where the fog is in a tree’s or a house’s shadow it stops glowing, so beams of sunlight show between them. It needs fog, a fog_sun_glow and the sun’s shadows, and reaches as far as they do. It costs 16 shadow map taps per pixel, and it is grainy without AntiAliasing::Taa in ctx.post, which smooths it out.

Implementations

impl Sky

pub fn sun_direction_at(hour: f32) -> Vec3

Which way sunlight travels at hour o’clock (0 to 24), for a day and night cycle: the sun rises in the east (+X) at 6, is highest at noon (60° up, to the south, -Z) and sets in the west at 18.

assert!(Sky::sun_direction_at(12.0).y < -0.8, "noon: from high up");
assert!(Sky::sun_direction_at(0.0).y > 0.0, "midnight: from below the ground");

Examples found in repository

examples/scene_viewer.rs (line 114)

fn main() {
    let scene = std::env::var("SCENE").unwrap_or_else(|_| {
        eprintln!("say which scene: SCENE=town/Town.json (a file under assets/)");
        std::process::exit(2);
    });
    if std::env::var("HEADLESS").is_ok() {
        Game::new("scene viewer", 1, 1).run_headless(0, |ctx| {
            let start = Instant::now();
            ctx.load_scene(&scene).unwrap_or_else(|e| panic!("{e}"));
            let models = ctx.world.query::<&Model>().iter().count();
            let (middle, size) = extent(&mut ctx.world);
            println!(
                "{scene}: {models} models in {:.2} s, around {middle} across {size:.0} m",
                start.elapsed().as_secs_f32()
            );
        });
        return;
    }
    let shot = std::env::var("SHOT").ok();
    let (mut yaw, mut pitch) = (0.0f32, -0.3f32);
    Game::new("Crabby Engine: scene viewer", 1280, 720)
        .system(move |ctx: &mut Ctx| {
            if ctx.key_pressed(Key::Escape) {
                ctx.quit();
            }
            let dt = ctx.dt();
            if ctx.frame() == 1 {
                let (y, x, _) = ctx.camera3d.rotation.to_euler(glam::EulerRot::YXZ);
                (yaw, pitch) = (y, x);
            }
            let turn = 1.2 * dt;
            if ctx.key_down(Key::Left) {
                yaw += turn;
            }
            if ctx.key_down(Key::Right) {
                yaw -= turn;
            }
            if ctx.key_down(Key::Up) {
                pitch = (pitch + turn).min(1.5);
            }
            if ctx.key_down(Key::Down) {
                pitch = (pitch - turn).max(-1.5);
            }
            let rotation = Quat::from_rotation_y(yaw) * Quat::from_rotation_x(pitch);
            let speed = if ctx.key_down(Key::LeftShift) { 120.0 } else { 20.0 } * dt;
            let mut go = Vec3::ZERO;
            for (key, way) in [
                (Key::W, Vec3::NEG_Z),
                (Key::S, Vec3::Z),
                (Key::A, Vec3::NEG_X),
                (Key::D, Vec3::X),
            ] {
                if ctx.key_down(key) {
                    go += rotation * way;
                }
            }
            if ctx.key_down(Key::E) {
                go += Vec3::Y;
            }
            if ctx.key_down(Key::Q) {
                go -= Vec3::Y;
            }
            ctx.camera3d.position += go * speed;
            ctx.camera3d.rotation = rotation;
            if ctx.frame() == 300
                && let Some(path) = &shot
            {
                ctx.save_screenshot(path);
            }
            if ctx.frame() == 302 && shot.is_some() {
                ctx.quit();
            }
        })
        .run(move |ctx| {
            ctx.load_scene(&scene).unwrap_or_else(|e| panic!("{e}"));
            ctx.lighting.sun_direction = Sky::sun_direction_at(15.0);
            ctx.lighting.shadow_distance = 400.0;
            ctx.camera3d.far = 3000.0;
            ctx.post.bloom = 0.05;
            let (middle, size) = extent(&mut ctx.world);
            let (at, yaw, pitch) =
                camera_from_env().unwrap_or((middle + vec3(0.0, size * 0.25, size * 0.4), 0.0, -0.5));
            ctx.camera3d.position = at;
            ctx.camera3d.rotation = Quat::from_rotation_y(yaw) * Quat::from_rotation_x(pitch);
        });
}

examples/compute.rs (line 93)

fn main() {
    let mut seed = 11u32;
    let mut random = move || {
        seed = seed.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
        (seed >> 8) as f32 / (1 << 24) as f32
    };
    let mut next_drop = 0.0;
    Game::new("Crabby Engine: compute", 1280, 720)
        .system(move |ctx: &mut Ctx| {
            if ctx.key_pressed(Key::Escape) {
                ctx.quit();
            }
            let Some(pass) = ctx.compute_passes.first().copied() else {
                return;
            };
            let Some(drops) = pass.material else { return };
            // Rain every so often, or a stone where the mouse clicks.
            let mut drop = Vec4::ZERO;
            next_drop -= ctx.dt();
            if next_drop <= 0.0 {
                next_drop = 0.05 + random() * 0.2;
                drop = vec4(random(), random(), 0.3 + random() * 0.4, 0.0);
            }
            if ctx.mouse_pressed(MouseButton::Left) {
                let (from, dir) = ctx.camera3d.screen_ray(ctx.mouse_pos());
                if dir.y < 0.0 {
                    let at = from + dir * (-from.y / dir.y);
                    drop = vec4(at.x / SIZE + 0.5, at.z / SIZE + 0.5, 3.0, 0.0);
                }
            }
            ctx.update_material(
                drops,
                MaterialDesc {
                    custom: [drop, Vec4::ZERO, Vec4::ZERO, Vec4::ZERO],
                    ..Default::default()
                },
            );
            if ctx.frame() == 120
                && let Ok(path) = std::env::var("SHOT")
            {
                ctx.save_screenshot(path);
            }
            if ctx.frame() == 122 && std::env::var("SHOT").is_ok() {
                ctx.quit();
            }
        })
        .run(|ctx| {
            ctx.camera3d.position = vec3(0.0, 7.0, 10.0);
            ctx.camera3d.look_at(vec3(0.0, 0.0, -1.0));
            ctx.lighting.sun_direction = Sky::sun_direction_at(15.0);
            ctx.post.bloom = 0.15;

            let heights = ctx.create_render_target(512, 512);
            let ripples = ctx.create_compute("ripples", RIPPLES);
            let drops = ctx.create_material(MaterialDesc::default());
            ctx.compute_passes
                .push(ComputePass::new(ripples, heights).with_material(drops));

            let shader = ctx.create_shader("water", WATER);
            let water = ctx.create_material(MaterialDesc {
                shader: Some(shader),
                custom_textures: [Some(heights), None],
                ..MaterialDesc::color(Color::hex(0x2A5A75))
            });
            let surface = ctx.create_mesh(&MeshData::plane(SIZE), water);
            ctx.world.spawn((Transform3D::default(), Model::new(surface)));

            let stone = ctx.create_material(MaterialDesc {
                roughness: 0.8,
                ..MaterialDesc::color(Color::hex(0x8A8578))
            });
            let rock = ctx.create_mesh(&MeshData::sphere(0.6, 16), stone);
            for i in 0..40 {
                let a = i as f32 / 40.0 * std::f32::consts::TAU;
                let edge = vec3(a.cos(), 0.0, a.sin()) * SIZE * 0.55;
                let t = Transform3D {
                    scale: Vec3::splat(0.8 + (i % 3) as f32 * 0.3),
                    ..Transform3D::at(edge)
                };
                ctx.world.spawn((t, Model::new(rock)));
            }
            let grass = ctx.create_material(MaterialDesc {
                roughness: 0.95,
                ..MaterialDesc::color(Color::hex(0x4E6B33))
            });
            let ground = ctx.create_mesh(&MeshData::plane(200.0), grass);
            ctx.world
                .spawn((Transform3D::at(vec3(0.0, -0.3, 0.0)), Model::new(ground)));
        });
}

examples/streaming.rs (line 187)

fn main() {
    let bench = std::env::var("BENCH").is_ok();
    let shot = std::env::var("SHOT").ok();
    let mut cells = CellStreamer::new(TILE, LOAD, KEEP);
    let mut tiles: HashMap<(i32, i32), Tile> = HashMap::new();
    let mut ground: Option<Material> = None;
    let (mut yaw, mut speed, mut altitude) = (0.4f32, if bench { 600.0f32 } else { 120.0 }, 90.0f32);
    // The streaming's cost on the game's thread, for BENCH.
    let (mut uploaded, mut freed, mut upload_time, mut worst_upload) = (0usize, 0usize, 0.0f64, 0.0f64);
    Game::new("Crabby Engine: streaming", 1280, 720)
        .vsync(!bench)
        .system(move |ctx: &mut Ctx| {
            if ctx.key_pressed(Key::Escape) {
                ctx.quit();
            }
            let dt = ctx.dt();
            if ctx.key_down(Key::Left) {
                yaw += dt * 0.8;
            }
            if ctx.key_down(Key::Right) {
                yaw -= dt * 0.8;
            }
            if ctx.key_down(Key::W) {
                speed = (speed + 80.0 * dt).min(600.0);
            }
            if ctx.key_down(Key::S) {
                speed = (speed - 80.0 * dt).max(0.0);
            }
            if ctx.key_down(Key::E) {
                altitude += 40.0 * dt;
            }
            if ctx.key_down(Key::Q) {
                altitude = (altitude - 40.0 * dt).max(5.0);
            }
            // Fly on, keeping above the hills ahead.
            let rotation = Quat::from_rotation_y(yaw);
            let mut at = ctx.camera3d.position + rotation * Vec3::NEG_Z * speed * dt;
            let ahead = at + rotation * Vec3::NEG_Z * 120.0;
            let floor = height(at.x, at.z).max(height(ahead.x, ahead.z));
            at.y += (floor + altitude - at.y) * (dt * 1.5).min(1.0);
            ctx.camera3d.position = at;
            ctx.camera3d.rotation = rotation * Quat::from_rotation_x(-0.22);

            // Which tiles to start and drop.
            cells.update(at, STARTS);
            for &cell in cells.to_load() {
                let corner = cells.corner(cell);
                tiles.insert(cell, Tile::Building(Job::spawn(move || tile_data(corner))));
            }
            for cell in cells.to_drop() {
                // A job still building is dropped with its result.
                if let Some(Tile::Live(entity, tile)) = tiles.remove(cell) {
                    ctx.world.despawn(entity);
                    ctx.free_terrain_tile(tile);
                    freed += 1;
                }
            }
            // Finished tiles go on the GPU, a few a frame.
            let ground = *ground.get_or_insert_with(|| {
                let shader = ctx.create_shader("ground", GROUND);
                ctx.create_material(MaterialDesc {
                    shader: Some(shader),
                    ..MaterialDesc::color(Color::WHITE)
                })
            });
            let mut uploads = 0;
            for (&cell, tile) in tiles.iter_mut() {
                if uploads == UPLOADS {
                    break;
                }
                if let Tile::Building(job) = tile
                    && let Some(data) = job.take()
                {
                    let start = Instant::now();
                    let made = ctx.upload_terrain_tile(&data, ground);
                    let entity = ctx.world.spawn((Transform3D::at(cells.corner(cell)), made));
                    let took = start.elapsed().as_secs_f64() * 1000.0;
                    upload_time += took;
                    worst_upload = worst_upload.max(took);
                    uploaded += 1;
                    uploads += 1;
                    *tile = Tile::Live(entity, made);
                }
            }

            if ctx.frame() == 400
                && let Some(path) = &shot
            {
                ctx.save_screenshot(path);
            }
            if ctx.frame() == 402 && shot.is_some() {
                ctx.quit();
            }
            if bench && ctx.frame() == 3000 {
                let live = tiles.values().filter(|t| matches!(t, Tile::Live(..))).count();
                println!(
                    "{uploaded} tiles uploaded ({:.2} ms each, worst {worst_upload:.2} ms), {freed} freed, {live} live; {:?}",
                    upload_time / uploaded.max(1) as f64,
                    ctx.render_stats()
                );
                ctx.quit();
            }
        })
        .run(move |ctx| {
            ctx.post.bloom = 0.08;
            ctx.lighting.sun_direction = Sky::sun_direction_at(15.5);
            ctx.lighting.shadow_distance = 500.0;
            ctx.camera3d.far = LOAD + TILE;
            // Fog thick enough that tiles appear behind it, not at an edge.
            ctx.sky.fog_density = 0.0007;
            ctx.sky.fog_height = 40.0;
            ctx.sky.fog_falloff = 90.0;
            ctx.camera3d.position = vec3(0.0, height(0.0, 0.0) + 60.0, 0.0);
        });
}

examples/shaders.rs (line 59)

fn main() {
    let env = |name| std::env::var(name).ok().and_then(|v| v.parse::<f32>().ok());
    let mut hour = env("HOUR").unwrap_or(15.5);
    let mut fog = env("FOG").unwrap_or(0.0) > 0.0;
    Game::new("Crabby Engine: shaders", 1280, 720)
        .system(move |ctx: &mut Ctx| {
            if ctx.key_pressed(Key::Escape) {
                ctx.quit();
            }
            // Two hours a second.
            if ctx.key_down(Key::Right) {
                hour = (hour + ctx.dt() * 2.0) % 24.0;
            }
            if ctx.key_down(Key::Left) {
                hour = (hour - ctx.dt() * 2.0).rem_euclid(24.0);
            }
            if ctx.key_pressed(Key::F) {
                fog = !fog;
            }
            ctx.lighting.sun_direction = Sky::sun_direction_at(hour);
            ctx.sky.fog_density = if fog { 0.02 } else { 0.0 };
            ctx.sky.fog_falloff = 8.0;
            if ctx.frame() == 2
                && let Ok(path) = std::env::var("SHOT")
            {
                ctx.save_screenshot(path);
            }
            if ctx.frame() == 4 && std::env::var("SHOT").is_ok() {
                ctx.quit();
            }
        })
        .run(|ctx| {
            ctx.clear(Color::hex(0x9CC4E4));
            ctx.camera3d.position = vec3(0.0, 4.0, 11.0);
            ctx.camera3d.look_at(vec3(0.0, 0.5, 0.0));
            ctx.post.bloom = 0.1;

            let ground_look = MaterialDesc {
                roughness: 0.95,
                ..MaterialDesc::color(Color::hex(0x5E7A3A))
            };
            let ground = ctx.create_material(ground_look);
            let ground = ctx.create_mesh(&MeshData::plane(600.0), ground);
            ctx.world.spawn((Transform3D::default(), Model::new(ground)));

            let water = ctx.load_shader("shaders/water.wgsl");
            let lake = ctx.create_material(MaterialDesc {
                shader: Some(water),
                blend: Blend::Transparent,
                custom: [vec4(0.06, 1.5, 1.2, 1.2), Vec4::ZERO, Vec4::ZERO, Vec4::ZERO],
                ..MaterialDesc::color(Color::hex(0x1E4D6B))
            });
            let mut surface = MeshData::plane(12.0);
            // More vertices, so the waves have something to move.
            surface = subdivide(surface, 5);
            let lake = ctx.create_mesh(&surface, lake);
            ctx.world
                .spawn((Transform3D::at(vec3(-3.0, 0.15, -4.0)), Model::new(lake)));

            // The lake bed, under the water: sand sloping down, and stones.
            let sand = ctx.create_material(MaterialDesc {
                roughness: 0.9,
                ..MaterialDesc::color(Color::hex(0xC2A878))
            });
            let bed = ctx.create_mesh(&MeshData::plane(12.0), sand);
            let tilt = Quat::from_rotation_x(0.12);
            ctx.world.spawn((
                Transform3D {
                    rotation: tilt,
                    ..Transform3D::at(vec3(-3.0, -0.6, -4.0))
                },
                Model::new(bed),
            ));
            let stone = ctx.create_material(MaterialDesc {
                roughness: 0.7,
                ..MaterialDesc::color(Color::hex(0x8A8A80))
            });
            let pebble = ctx.create_mesh(&MeshData::sphere(0.35, 16), stone);
            for i in 0..12 {
                let at = vec3(
                    -7.0 + i as f32 * 0.8,
                    -0.3 - (i % 3) as f32 * 0.2,
                    -3.0 + (i % 4) as f32 * -1.5,
                );
                ctx.world.spawn((Transform3D::at(at), Model::new(pebble)));
            }

            let wind = ctx.load_shader("shaders/wind.wgsl");
            let grass = ctx.create_material(MaterialDesc {
                shader: Some(wind),
                double_sided: true,
                roughness: 0.8,
                custom: [vec4(0.25, 2.0, 0.0, 0.0), Vec4::ZERO, Vec4::ZERO, Vec4::ZERO],
                ..MaterialDesc::color(Color::hex(0x7FA83C))
            });
            let blade = ctx.create_mesh(&blade(), grass);
            let mut seed = 7u32;
            let mut random = move || {
                seed = seed.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
                (seed >> 8) as f32 / (1 << 24) as f32
            };
            for _ in 0..6000 {
                let at = vec3(random() * 14.0 - 2.0, 0.0, random() * 10.0 - 3.0);
                if at.x < 4.0 && at.z < 2.5 {
                    continue; // the lake
                }
                let t = Transform3D {
                    rotation: Quat::from_rotation_y(random() * 6.3),
                    scale: Vec3::splat(0.6 + random() * 0.8),
                    ..Transform3D::at(at)
                };
                ctx.world.spawn((t, Model::new(blade)));
            }

            let tiles = ctx.create_shader("tiles", TILES);
            let ball = ctx.create_material(MaterialDesc {
                shader: Some(tiles),
                ..Default::default()
            });
            let ball = ctx.create_mesh(&MeshData::sphere(1.0, 48), ball);
            ctx.world
                .spawn((Transform3D::at(vec3(3.5, 1.0, 1.0)), Model::new(ball)));
        });
}

examples/terrain.rs (line 257)

fn main() {
    let view = std::env::var("VIEW").unwrap_or_default();
    let hour = std::env::var("HOUR").ok().and_then(|h| h.parse().ok()).unwrap_or(16.0);
    // The first spot nearest the middle where the ground fits.
    let spot = |fits: &dyn Fn(f32) -> bool| {
        (0..200 * 200)
            .map(|i| vec2((i % 200) as f32 * 4.0 - 400.0, (i / 200) as f32 * 4.0 - 400.0))
            .filter(|p| fits(height(p.x, p.y)))
            .min_by(|a, b| a.length().total_cmp(&b.length()))
            .unwrap_or(Vec2::ZERO)
    };
    let (start, (mut yaw, mut pitch)) = match view.as_str() {
        "low" => {
            let p = spot(&|h| h > WATER + 4.0);
            (vec3(p.x, height(p.x, p.y) + 1.8, p.y), (0.6f32, -0.08f32))
        }
        "under" => {
            let p = spot(&|h| h < WATER - 2.0 && h > WATER - 5.0);
            (vec3(p.x, WATER - 1.0, p.y), (0.6, -0.6))
        }
        "cliff" => {
            // The steepest ground near the middle, seen from 30 m off its foot.
            let slope = |p: Vec2| {
                (height(p.x + 2.0, p.y) - height(p.x - 2.0, p.y)).hypot(height(p.x, p.y + 2.0) - height(p.x, p.y - 2.0))
            };
            let steep = (0..200 * 200)
                .map(|i| vec2((i % 200) as f32 * 4.0 - 400.0, (i / 200) as f32 * 4.0 - 400.0))
                .filter(|p| height(p.x, p.y) > WATER + 2.0)
                .max_by(|a, b| slope(*a).total_cmp(&slope(*b)))
                .unwrap_or(Vec2::ZERO);
            // Downhill, away from the face.
            let down = -vec2(
                height(steep.x + 2.0, steep.y) - height(steep.x - 2.0, steep.y),
                height(steep.x, steep.y + 2.0) - height(steep.x, steep.y - 2.0),
            )
            .normalize_or_zero();
            let eye = steep + down * 30.0;
            let at = vec3(eye.x, height(eye.x, eye.y).max(WATER) + 6.0, eye.y);
            let to = vec3(steep.x, height(steep.x, steep.y), steep.y) - at;
            (at, (f32::atan2(-to.x, -to.z), (to.y / to.length()).asin()))
        }
        _ => (vec3(-300.0, 90.0, 300.0), (-0.8, -0.25)),
    };
    let mut parked: Vec<ScreenEffect> = Vec::new();
    let bench = std::env::var("BENCH").is_ok();
    Game::new("Crabby Engine: terrain", 1280, 720)
        .vsync(!bench)
        .fullscreen(bench)
        .system(move |ctx: &mut Ctx| {
            if ctx.key_pressed(Key::Escape) {
                ctx.quit();
            }
            let dt = ctx.dt();
            if ctx.key_down(Key::Left) {
                yaw += dt;
            }
            if ctx.key_down(Key::Right) {
                yaw -= dt;
            }
            if ctx.key_down(Key::Up) {
                pitch = (pitch + dt).min(1.4);
            }
            if ctx.key_down(Key::Down) {
                pitch = (pitch - dt).max(-1.4);
            }
            let rotation = Quat::from_rotation_y(yaw) * Quat::from_rotation_x(pitch);
            let forward = rotation * Vec3::NEG_Z;
            let right = rotation * Vec3::X;
            let speed = 60.0 * dt;
            let mut go = Vec3::ZERO;
            for (key, dir) in [
                (Key::W, forward),
                (Key::S, -forward),
                (Key::D, right),
                (Key::A, -right),
                (Key::E, Vec3::Y),
                (Key::Q, Vec3::NEG_Y),
            ] {
                if ctx.key_down(key) {
                    go += dir;
                }
            }
            ctx.camera3d.position += go * speed;
            ctx.camera3d.rotation = rotation;
            // The lake's mirror follows the camera.
            if let Some(mirror) = ctx.target_cameras.first().map(|c| c.target) {
                ctx.target_cameras[0] = TargetCamera::reflection(ctx.camera3d, mirror, WATER);
            }
            if ctx.key_pressed(Key::U) {
                std::mem::swap(&mut ctx.effects, &mut parked);
            }
            if ctx.frame() == 3
                && let Ok(path) = std::env::var("SHOT")
            {
                ctx.save_screenshot(path);
            }
            if ctx.frame() == 5 && std::env::var("SHOT").is_ok() {
                ctx.quit();
            }
            if ctx.frame() == 300 {
                let stats = ctx.render_stats();
                println!("{stats:?} models drawn: {}", ctx.models_drawn());
                if bench {
                    ctx.quit();
                }
            }
        })
        .run(move |ctx| {
            ctx.post.bloom = 0.1;
            ctx.lighting.sun_direction = Sky::sun_direction_at(hour);
            ctx.lighting.shadow_distance = 400.0;
            ctx.camera3d.far = 3000.0;
            ctx.sky.fog_density = 0.0015;
            ctx.sky.fog_height = 0.0;
            ctx.sky.fog_falloff = 60.0;

            let ground = ground(ctx);
            let half = TILES / 2;
            for tz in -half..=half {
                for tx in -half..=half {
                    let corner = vec3(tx as f32 * TILE - TILE / 2.0, 0.0, tz as f32 * TILE - TILE / 2.0);
                    let heights: Vec<f32> = (0..N * N)
                        .map(|i| height(corner.x + (i % N) as f32 * 2.0, corner.z + (i / N) as f32 * 2.0))
                        .collect();
                    let tile = ctx.create_terrain_tile(&heights, TILE, ground);
                    ctx.world.spawn((Transform3D::at(corner), tile));
                }
            }

            // Half the window's size is plenty for a rippled mirror.
            let size = ctx.window_size();
            let mirror = ctx.create_render_target((size.x as u32 / 2).max(1), (size.y as u32 / 2).max(1));
            ctx.target_cameras
                .push(TargetCamera::reflection(ctx.camera3d, mirror, WATER));
            let water = ctx.create_shader("lake", LAKE);
            let lake = ctx.create_material(MaterialDesc {
                shader: Some(water),
                blend: Blend::Transparent,
                custom_textures: [Some(mirror), None],
                custom: [vec4(0.06, 1.5, 1.2, 1.2), Vec4::ZERO, Vec4::ZERO, Vec4::ZERO],
                ..MaterialDesc::color(Color::hex(0x1E4D6B))
            });
            let surface = ctx.create_mesh(&MeshData::plane(TILES as f32 * TILE), lake);
            ctx.world
                .spawn((Transform3D::at(vec3(0.0, WATER, 0.0)), Model::new(surface)));

            let underwater = ctx.create_effect("underwater", UNDERWATER);
            let level = ctx.create_material(MaterialDesc {
                custom: [vec4(WATER, 0.0, 0.0, 0.0), Vec4::ZERO, Vec4::ZERO, Vec4::ZERO],
                ..Default::default()
            });
            ctx.effects.push(ScreenEffect::new(underwater).with_material(level));

            ctx.camera3d.position = start;
        });
}

Trait Implementations

impl Clone for Sky

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Sky

impl Debug for Sky

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Sky

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for Sky

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Sky