Add real lightning bolts
Thunderstorms now roll ServerLevel.tickThunder per chunk: the bolt strikes the top of the column or a living entity under open sky nearby, may bring a skeleton trap horse, and LightningBolt ticks its flashes with the thunder and impact sounds, fire, lightning rods and thunderHit (5 damage and burning, charged creepers with their energy swirl, zombified piglins, witches, mooshroom colours, turtles, burnt items). The bolt is drawn by LightningBoltRenderer's layered branches through a new additive entity pipeline, and /summon accepts lightning bolts and minecarts. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -149,11 +149,11 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
|
||||
for (key, value) in [
|
||||
("Fuse", Tag::Short(30)),
|
||||
("ExplosionRadius", Tag::Byte(3)),
|
||||
("powered", Tag::Byte(0)),
|
||||
("ignited", Tag::Byte(0)),
|
||||
] {
|
||||
map.entry(key.into()).or_insert(value);
|
||||
}
|
||||
map.insert("powered".into(), Tag::Byte(i8::from(m.extra.charged)));
|
||||
}
|
||||
// Skeletons are spawned holding a bow (finalizeSpawn); a mob loaded
|
||||
// from NBT keeps only its saved equipment.
|
||||
@@ -212,6 +212,9 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
|
||||
m.persistent = flag(tag, "PersistenceRequired");
|
||||
m.custom_name = custom_name(tag);
|
||||
m.name_visible = flag(tag, "CustomNameVisible");
|
||||
if m.species() == crate::mobs::Species::Creeper {
|
||||
m.extra.charged = flag(tag, "powered");
|
||||
}
|
||||
// A mob saved mid-death finishes dying; one saved dead is dropped.
|
||||
if m.health <= 0.0 && m.death_time == 0 {
|
||||
return None;
|
||||
|
||||
@@ -17,6 +17,7 @@ mod fov;
|
||||
mod frames;
|
||||
mod growth;
|
||||
mod jukebox;
|
||||
mod lightning;
|
||||
mod machines;
|
||||
mod minecarts;
|
||||
mod music;
|
||||
@@ -552,6 +553,7 @@ struct Game<'a> {
|
||||
carts: Vec<minecarts::Minecart>,
|
||||
/// Songs playing from jukeboxes (tracked sound handles).
|
||||
jukebox_sounds: HashMap<(i32, i32, i32), u64>,
|
||||
bolts: Vec<lightning::Bolt>,
|
||||
cart_models: minecarts::CartModels,
|
||||
/// The boat the player rides.
|
||||
riding: Option<u32>,
|
||||
@@ -2245,6 +2247,8 @@ impl Game<'_> {
|
||||
self.tick_armor_stands();
|
||||
self.tick_boats();
|
||||
self.tick_carts();
|
||||
self.tick_thunder();
|
||||
self.tick_bolts();
|
||||
self.tick_fishing();
|
||||
self.tick_tridents();
|
||||
self.tick_rockets();
|
||||
@@ -5729,7 +5733,7 @@ impl Game<'_> {
|
||||
if self.flash > 0 {
|
||||
self.flash -= 1;
|
||||
}
|
||||
let (rain, thunder) = self.world.weather.levels(1.0);
|
||||
let (rain, _) = self.world.weather.levels(1.0);
|
||||
let Some(eye) = self.eye_position() else {
|
||||
return;
|
||||
};
|
||||
@@ -5760,38 +5764,6 @@ impl Game<'_> {
|
||||
);
|
||||
}
|
||||
}
|
||||
// ServerLevel.tickChunk lightning: 1 in 100000 per chunk per tick while thundering.
|
||||
if thunder > 0.0 && self.world.weather.thundering {
|
||||
let chunks = self.world.chunks.len().max(1) as i32;
|
||||
if self
|
||||
.world
|
||||
.random
|
||||
.next_int_bound((100_000 / chunks).max(1))
|
||||
.unwrap_or(1)
|
||||
== 0
|
||||
{
|
||||
self.flash = 2;
|
||||
let r = &mut self.world.random;
|
||||
let (dx, dz) = (
|
||||
f64::from(r.next_int_bound(160).unwrap_or(0) - 80),
|
||||
f64::from(r.next_int_bound(160).unwrap_or(0) - 80),
|
||||
);
|
||||
let at = [eye[0] + dx, eye[1], eye[2] + dz];
|
||||
let pitch = 0.8 + self.world.random.next_float() * 0.2;
|
||||
self.audio.play(
|
||||
"minecraft:entity.lightning_bolt.thunder",
|
||||
Some(at),
|
||||
10000.0,
|
||||
pitch,
|
||||
);
|
||||
self.audio.play(
|
||||
"minecraft:entity.lightning_bolt.impact",
|
||||
Some(at),
|
||||
2.0,
|
||||
0.5 + self.world.random.next_float() * 0.2,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
/// WeatherEffectRenderer: rain/snow columns within 10 blocks.
|
||||
fn weather_geometry(&self, camera: glam::DVec3, alpha: f64, out: &mut Vec<Vertex>) {
|
||||
@@ -6384,6 +6356,10 @@ impl Game<'_> {
|
||||
} else {
|
||||
self.entity_geometry(camera, alpha)
|
||||
};
|
||||
let mut additive = Vec::new();
|
||||
if !title {
|
||||
self.bolt_geometry(camera, &mut additive);
|
||||
}
|
||||
let celestial = if title {
|
||||
self.panorama_geometry()
|
||||
} else if self.dim == Dim::Overworld {
|
||||
@@ -6460,6 +6436,7 @@ impl Game<'_> {
|
||||
outline,
|
||||
hud: &hud,
|
||||
entities: &entities,
|
||||
additive: &additive,
|
||||
celestial: &celestial,
|
||||
hand: &hand,
|
||||
screen: &screen,
|
||||
@@ -7287,6 +7264,7 @@ pub fn run() -> Result<()> {
|
||||
boat_models: boats::BoatModels::load(&root),
|
||||
carts: Vec::new(),
|
||||
jukebox_sounds: HashMap::new(),
|
||||
bolts: Vec::new(),
|
||||
cart_models: minecarts::CartModels::load(&root),
|
||||
riding: None,
|
||||
ender_items: vec![None; 27],
|
||||
|
||||
@@ -141,6 +141,12 @@ impl Game<'_> {
|
||||
"minecraft:experience_orb",
|
||||
"minecraft:falling_block",
|
||||
"minecraft:arrow",
|
||||
"minecraft:lightning_bolt",
|
||||
"minecraft:minecart",
|
||||
"minecraft:chest_minecart",
|
||||
"minecraft:hopper_minecart",
|
||||
"minecraft:furnace_minecart",
|
||||
"minecraft:tnt_minecart",
|
||||
]
|
||||
.map(String::from),
|
||||
);
|
||||
|
||||
@@ -1068,6 +1068,22 @@ impl Game<'_> {
|
||||
});
|
||||
name = Text::translate("entity.minecraft.experience_orb", &[]);
|
||||
}
|
||||
"lightning_bolt" => {
|
||||
self.spawn_bolt(pos, false);
|
||||
name = Text::translate("entity.minecraft.lightning_bolt", &[]);
|
||||
}
|
||||
k if super::minecarts::CartKind::from_id(&kind).is_some() => {
|
||||
let cart_kind = super::minecarts::CartKind::from_id(&kind)
|
||||
.unwrap_or(super::minecarts::CartKind::Rideable);
|
||||
self.next_entity += 1;
|
||||
let cart = super::minecarts::Minecart::new(
|
||||
self.next_entity,
|
||||
cart_kind,
|
||||
Vec3::new(pos[0], pos[1], pos[2]),
|
||||
);
|
||||
self.carts.push(cart);
|
||||
name = Text::translate(&format!("entity.minecraft.{k}"), &[]);
|
||||
}
|
||||
_ => return Err(err("commands.summon.failed", &[])),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,391 @@
|
||||
//! Lightning (`ServerLevel.tickThunder`, `LightningBolt`,
|
||||
//! `LightningBoltRenderer`): strikes on the highest motion-blocking block or
|
||||
//! a living entity under open sky nearby, skeleton trap horses, fire,
|
||||
//! `thunderHit` (damage and burning, charged creepers, zombified piglins,
|
||||
//! witches, mooshroom colours, turtles, burnt items), lightning rods, the sky
|
||||
//! flash, the sounds and the branching additive bolt.
|
||||
use super::Game;
|
||||
use horizon_client::{
|
||||
mesher::Vertex,
|
||||
mobs::{Damage, DamageKind, MobEvent, SpawnSetup, Species},
|
||||
};
|
||||
use horizon_core::{
|
||||
position::BlockPos,
|
||||
random::{LegacyRandom, RandomSource},
|
||||
};
|
||||
|
||||
pub(super) struct Bolt {
|
||||
at: [f64; 3],
|
||||
life: i32,
|
||||
flashes: i32,
|
||||
seed: i64,
|
||||
visual_only: bool,
|
||||
/// Mooshrooms switch colour once per bolt.
|
||||
converted: Vec<u32>,
|
||||
}
|
||||
impl Game<'_> {
|
||||
/// One `tickThunder` roll per loaded chunk.
|
||||
pub(super) fn tick_thunder(&mut self) {
|
||||
// isRaining (rain level > 0.2) and isThundering (> 0.9, sky light, no ceiling).
|
||||
let (rain, thunder) = self.world.weather.levels(1.0);
|
||||
if rain <= 0.2 || thunder <= 0.9 || self.dim != super::Dim::Overworld {
|
||||
return;
|
||||
}
|
||||
let chunks: Vec<(i32, i32)> = self.world.chunks.keys().copied().collect();
|
||||
for (cx, cz) in chunks {
|
||||
if self.world.random.next_int_bound(100_000).unwrap_or(1) != 0 {
|
||||
continue;
|
||||
}
|
||||
// getBlockRandomPos(minX, 0, minZ, 15)
|
||||
let r = self.world.random.next_int();
|
||||
let (x, z) = (cx * 16 + (r & 15), cz * 16 + (r >> 16 & 15));
|
||||
let Some(pos) = self.lightning_target(x, z) else {
|
||||
continue;
|
||||
};
|
||||
let p = BlockPos::new(pos[0], pos[1], pos[2]);
|
||||
if !self.with_level(|b, level, _| b.is_raining_at(level, p)) {
|
||||
continue;
|
||||
}
|
||||
// Skeleton trap: effective difficulty / 100 (regional difficulty approximated).
|
||||
let difficulty = f64::from(self.ui.difficulty) * 0.75;
|
||||
let below = &self
|
||||
.res
|
||||
.facts
|
||||
.get(self.world.block(pos[0], pos[1] - 1, pos[2]))
|
||||
.name;
|
||||
let trap = self.ui.rules.bool("spawn_mobs")
|
||||
&& self.world.random.next_double() < difficulty * 0.01
|
||||
&& !below.ends_with("lightning_rod");
|
||||
if trap {
|
||||
let at = [f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])];
|
||||
let _ = self.spawn_mob("minecraft:skeleton_horse", at, false);
|
||||
}
|
||||
let at = [
|
||||
f64::from(pos[0]) + 0.5,
|
||||
f64::from(pos[1]),
|
||||
f64::from(pos[2]) + 0.5,
|
||||
];
|
||||
self.spawn_bolt(at, trap);
|
||||
}
|
||||
}
|
||||
/// `findLightningTargetAround`: a living entity under open sky in the
|
||||
/// column (3 blocks around), else the top of the column.
|
||||
fn lightning_target(&mut self, x: i32, z: i32) -> Option<[i32; 3]> {
|
||||
if !self.world.loaded(x, z) {
|
||||
return None;
|
||||
}
|
||||
let top =
|
||||
self.with_level(|b, level, _| b.motion_blocking_top(level, BlockPos::new(x, 0, z)));
|
||||
let sees_sky = |g: &Self, p: [i32; 3]| g.world.light(p[0], p[1], p[2]) >> 4 == 15;
|
||||
let mut candidates: Vec<[i32; 3]> = self
|
||||
.mobs
|
||||
.iter()
|
||||
.filter(|m| m.alive())
|
||||
.map(|m| {
|
||||
[
|
||||
m.position.x.floor() as i32,
|
||||
m.position.y.floor() as i32,
|
||||
m.position.z.floor() as i32,
|
||||
]
|
||||
})
|
||||
.filter(|p| (p[0] - x).abs() <= 3 && (p[2] - z).abs() <= 3 && p[1] >= top.y - 3)
|
||||
.filter(|p| sees_sky(self, *p))
|
||||
.collect();
|
||||
if let Some(p) = self
|
||||
.player
|
||||
.as_ref()
|
||||
.filter(|p| !p.health.dead_or_dying())
|
||||
.map(|p| {
|
||||
[
|
||||
p.position.x.floor() as i32,
|
||||
p.position.y.floor() as i32,
|
||||
p.position.z.floor() as i32,
|
||||
]
|
||||
})
|
||||
&& (p[0] - x).abs() <= 3
|
||||
&& (p[2] - z).abs() <= 3
|
||||
&& p[1] >= top.y - 3
|
||||
&& sees_sky(self, p)
|
||||
{
|
||||
candidates.push(p);
|
||||
}
|
||||
if !candidates.is_empty() {
|
||||
let i = self
|
||||
.world
|
||||
.random
|
||||
.next_int_bound(candidates.len() as i32)
|
||||
.unwrap_or(0) as usize;
|
||||
return Some(candidates[i]);
|
||||
}
|
||||
Some([x, top.y, z])
|
||||
}
|
||||
pub(super) fn spawn_bolt(&mut self, at: [f64; 3], visual_only: bool) {
|
||||
let r = &mut self.world.random;
|
||||
let seed = r.next_long();
|
||||
let flashes = r.next_int_bound(3).unwrap_or(0) + 1;
|
||||
self.bolts.push(Bolt {
|
||||
at,
|
||||
life: 2,
|
||||
flashes,
|
||||
seed,
|
||||
visual_only,
|
||||
converted: Vec::new(),
|
||||
});
|
||||
}
|
||||
/// `spawnFire`: fire at the strike point and `extra` random neighbours.
|
||||
fn bolt_fire(&mut self, at: [f64; 3], extra: i32) {
|
||||
if self.ui.difficulty < 2 {
|
||||
return;
|
||||
}
|
||||
let base = [
|
||||
at[0].floor() as i32,
|
||||
at[1].floor() as i32,
|
||||
at[2].floor() as i32,
|
||||
];
|
||||
let mut spots = vec![base];
|
||||
for _ in 0..extra {
|
||||
let r = &mut self.world.random;
|
||||
let mut d = || r.next_int_bound(3).unwrap_or(1) - 1;
|
||||
spots.push([base[0] + d(), base[1] + d(), base[2] + d()]);
|
||||
}
|
||||
for p in spots {
|
||||
let state = self.world.block(p[0], p[1], p[2]);
|
||||
if !self.res.facts.is_air(state) {
|
||||
continue;
|
||||
}
|
||||
// BaseFireBlock.getState: soul fire on soul soil and sand.
|
||||
let below = self.res.facts.get(self.world.block(p[0], p[1] - 1, p[2]));
|
||||
let name = if matches!(&*below.name, "minecraft:soul_soil" | "minecraft:soul_sand") {
|
||||
"minecraft:soul_fire"
|
||||
} else {
|
||||
"minecraft:fire"
|
||||
};
|
||||
// FireBlock.canSurvive: a sturdy floor (flammable neighbours aside).
|
||||
if below.sturdy_full >> 1 & 1 == 0 {
|
||||
continue;
|
||||
}
|
||||
if let Some(fire) = self.res.assets.registry.default_state(name) {
|
||||
let _ = self.level_set(p, fire);
|
||||
}
|
||||
}
|
||||
}
|
||||
/// `LightningBolt.tick` for every bolt.
|
||||
pub(super) fn tick_bolts(&mut self) {
|
||||
let mut bolts = std::mem::take(&mut self.bolts);
|
||||
bolts.retain_mut(|b| {
|
||||
if b.life == 2 {
|
||||
let pitch = 0.8 + self.world.random.next_float() * 0.2;
|
||||
self.audio.play(
|
||||
"minecraft:entity.lightning_bolt.thunder",
|
||||
Some(b.at),
|
||||
10000.0,
|
||||
pitch,
|
||||
);
|
||||
let pitch = 0.5 + self.world.random.next_float() * 0.2;
|
||||
self.audio.play(
|
||||
"minecraft:entity.lightning_bolt.impact",
|
||||
Some(b.at),
|
||||
2.0,
|
||||
pitch,
|
||||
);
|
||||
if !b.visual_only {
|
||||
self.bolt_fire(b.at, 4);
|
||||
self.strike_rod(b.at);
|
||||
}
|
||||
}
|
||||
b.life -= 1;
|
||||
if b.life < 0 {
|
||||
if b.flashes == 0 {
|
||||
return false;
|
||||
}
|
||||
if b.life < -self.world.random.next_int_bound(10).unwrap_or(0) {
|
||||
b.flashes -= 1;
|
||||
b.life = 1;
|
||||
b.seed = self.world.random.next_long();
|
||||
if !b.visual_only {
|
||||
self.bolt_fire(b.at, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
if b.life >= 0 {
|
||||
self.flash = 2;
|
||||
if !b.visual_only {
|
||||
self.thunder_hit(b);
|
||||
}
|
||||
}
|
||||
true
|
||||
});
|
||||
bolts.append(&mut self.bolts);
|
||||
self.bolts = bolts;
|
||||
}
|
||||
/// `LightningRodBlock.onLightningStrike`: powered for 8 ticks.
|
||||
fn strike_rod(&mut self, at: [f64; 3]) {
|
||||
let p = [
|
||||
at[0].floor() as i32,
|
||||
(at[1] - 1.0e-6).floor() as i32,
|
||||
at[2].floor() as i32,
|
||||
];
|
||||
let state = self.world.block(p[0], p[1], p[2]);
|
||||
if !self.res.facts.get(state).name.ends_with("lightning_rod") {
|
||||
return;
|
||||
}
|
||||
let registry = self.res.assets.registry;
|
||||
if let Some(mut s) = registry.state(state).cloned() {
|
||||
s.properties.insert("powered".into(), "true".into());
|
||||
if let Some(powered) = registry.id(&s) {
|
||||
// The rod's onPlace schedules the 8-tick unpowering.
|
||||
let _ = self.level_set(p, powered);
|
||||
}
|
||||
}
|
||||
}
|
||||
/// `thunderHit` for entities within 3 blocks (up to 9 above).
|
||||
fn thunder_hit(&mut self, b: &mut Bolt) {
|
||||
let inside = |p: [f64; 3]| {
|
||||
(p[0] - b.at[0]).abs() <= 3.0
|
||||
&& (p[2] - b.at[2]).abs() <= 3.0
|
||||
&& p[1] >= b.at[1] - 3.0
|
||||
&& p[1] <= b.at[1] + 9.0
|
||||
};
|
||||
let damage = Damage {
|
||||
kind: DamageKind::Generic,
|
||||
attacker: None,
|
||||
from: Some(b.at),
|
||||
};
|
||||
let mut events = Vec::new();
|
||||
let peaceful = self.ui.difficulty == 0;
|
||||
for m in self.mobs.iter_mut().filter(|m| m.alive()) {
|
||||
if !inside([m.position.x, m.position.y, m.position.z]) {
|
||||
continue;
|
||||
}
|
||||
let setup = |m: &horizon_client::mobs::Mob| SpawnSetup {
|
||||
yaw: m.yaw,
|
||||
persistent: true,
|
||||
..Default::default()
|
||||
};
|
||||
let at = [m.position.x, m.position.y, m.position.z];
|
||||
match m.species() {
|
||||
Species::Pig if !peaceful => {
|
||||
m.removed = true;
|
||||
events.push(MobEvent::SpawnKind {
|
||||
kind: "minecraft:zombified_piglin".into(),
|
||||
at,
|
||||
setup: setup(m),
|
||||
});
|
||||
continue;
|
||||
}
|
||||
Species::Villager if !peaceful => {
|
||||
m.removed = true;
|
||||
events.push(MobEvent::SpawnKind {
|
||||
kind: "minecraft:witch".into(),
|
||||
at,
|
||||
setup: setup(m),
|
||||
});
|
||||
continue;
|
||||
}
|
||||
Species::Mooshroom => {
|
||||
if !b.converted.contains(&m.id) {
|
||||
b.converted.push(m.id);
|
||||
m.extra.variant = 1 - m.extra.variant.min(1);
|
||||
self.audio
|
||||
.play("minecraft:entity.mooshroom.convert", Some(at), 2.0, 1.0);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
Species::Turtle => {
|
||||
m.damage(f32::MAX, damage);
|
||||
continue;
|
||||
}
|
||||
Species::Creeper => m.extra.charged = true,
|
||||
_ => {}
|
||||
}
|
||||
// Entity.thunderHit: burning (8 seconds) and 5 lightning damage.
|
||||
m.fire_ticks = if m.fire_ticks + 1 == 0 {
|
||||
160
|
||||
} else {
|
||||
m.fire_ticks + 1
|
||||
};
|
||||
m.damage(5.0, damage);
|
||||
}
|
||||
if !events.is_empty() {
|
||||
let _ = self.handle_mob_events(events);
|
||||
}
|
||||
if let Some(p) = self.player.as_ref().map(|p| p.position)
|
||||
&& inside([p.x, p.y, p.z])
|
||||
{
|
||||
let fire = &mut self.creatures.player_fire;
|
||||
*fire = if *fire + 1 == 0 { 160 } else { *fire + 1 };
|
||||
self.hurt_player_by("minecraft:lightning_bolt", 5.0);
|
||||
}
|
||||
// Dropped items burn up (ItemEntity health 5), save fire-resistant ones.
|
||||
self.dropped.retain(|e| {
|
||||
!inside([e.position.x, e.position.y, e.position.z])
|
||||
|| e.stack.item.contains("netherite")
|
||||
});
|
||||
}
|
||||
/// `LightningBoltRenderer`: 4 layers of a trunk and two branches, 8
|
||||
/// segments of 16 blocks, from the bolt's seed.
|
||||
pub(super) fn bolt_geometry(&self, camera: glam::DVec3, out: &mut Vec<Vertex>) {
|
||||
let white = self.res.atlas.font.white();
|
||||
let uv = [white.u0, white.v0];
|
||||
// ARGB 0.45, 0.45, 0.5 at 0.3 alpha, packed RGBA.
|
||||
let color = (76u32 << 24) | (127 << 16) | (114 << 8) | 114;
|
||||
for b in &self.bolts {
|
||||
let o = (glam::DVec3::from_array(b.at) - camera).as_vec3();
|
||||
let mut random = LegacyRandom::new(b.seed);
|
||||
let (mut xs, mut zs) = ([0f32; 8], [0f32; 8]);
|
||||
let (mut x_off, mut z_off) = (0f32, 0f32);
|
||||
for i in (0..8).rev() {
|
||||
xs[i] = x_off;
|
||||
zs[i] = z_off;
|
||||
x_off += (random.next_int_bound(11).unwrap_or(5) - 5) as f32;
|
||||
z_off += (random.next_int_bound(11).unwrap_or(5) - 5) as f32;
|
||||
}
|
||||
for layer in 0..4 {
|
||||
let mut random = LegacyRandom::new(b.seed);
|
||||
for branch in 0..3 {
|
||||
let trunk = branch == 0;
|
||||
let start = 7 - branch;
|
||||
let end = if trunk { 0 } else { start - 3 + 1 };
|
||||
let mut sx = xs[start] - x_off;
|
||||
let mut sz = zs[start] - z_off;
|
||||
for segment in (end..=start).rev() {
|
||||
let (ex, ez) = (sx, sz);
|
||||
let spread = if trunk { 11 } else { 31 };
|
||||
sx += (random.next_int_bound(spread).unwrap_or(0) - spread / 2) as f32;
|
||||
sz += (random.next_int_bound(spread).unwrap_or(0) - spread / 2) as f32;
|
||||
let mut top = 0.1 + layer as f32 * 0.2;
|
||||
let mut bottom = top;
|
||||
if trunk {
|
||||
top *= segment as f32 * 0.1 + 1.0;
|
||||
bottom *= (segment as f32 - 1.0) * 0.1 + 1.0;
|
||||
}
|
||||
for (rx, rz, lx, lz) in [
|
||||
(false, false, true, false),
|
||||
(true, false, true, true),
|
||||
(true, true, false, true),
|
||||
(false, true, false, false),
|
||||
] {
|
||||
let s = |p: bool, r: f32| if p { r } else { -r };
|
||||
let y0 = segment as f32 * 16.0;
|
||||
let corners = [
|
||||
[sx + s(rx, bottom), y0, sz + s(rz, bottom)],
|
||||
[ex + s(rx, top), y0 + 16.0, ez + s(rz, top)],
|
||||
[ex + s(lx, top), y0 + 16.0, ez + s(lz, top)],
|
||||
[sx + s(lx, bottom), y0, sz + s(lz, bottom)],
|
||||
];
|
||||
for c in corners {
|
||||
out.push(Vertex {
|
||||
pos: (o + glam::Vec3::from_array(c)).to_array(),
|
||||
uv,
|
||||
layer: 2,
|
||||
color,
|
||||
light: 240 | 240 << 8,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -67,6 +67,8 @@ pub struct Frame<'a> {
|
||||
pub hud: &'a HudBatch,
|
||||
/// Camera-relative entity geometry textured from the shared atlas.
|
||||
pub entities: &'a [Vertex],
|
||||
/// Additive translucent geometry after the entities (lightning, dragon rays).
|
||||
pub additive: &'a [Vertex],
|
||||
/// Camera-relative sun, moon and stars (drawn behind everything, additive).
|
||||
pub celestial: &'a [Vertex],
|
||||
/// First-person hand and held item, drawn after clearing depth.
|
||||
@@ -89,6 +91,7 @@ pub struct Renderer {
|
||||
dark_disc: wgpu::RenderPipeline,
|
||||
lines: wgpu::RenderPipeline,
|
||||
entity_pipeline: wgpu::RenderPipeline,
|
||||
additive_pipeline: wgpu::RenderPipeline,
|
||||
celestial_pipeline: wgpu::RenderPipeline,
|
||||
celestial_buffer: wgpu::Buffer,
|
||||
/// Screen effects: alpha-blended and vignette (`dst * (1 - src)`) pipelines.
|
||||
@@ -665,6 +668,52 @@ impl Renderer {
|
||||
multiview_mask: None,
|
||||
cache: None,
|
||||
});
|
||||
// BlendFunction.LIGHTNING: src alpha, one; no depth writes.
|
||||
let additive_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
|
||||
label: Some("Additive entities"),
|
||||
layout: Some(&entity_layout),
|
||||
vertex: wgpu::VertexState {
|
||||
module: &entity_shader,
|
||||
entry_point: Some("vs_entity"),
|
||||
compilation_options: Default::default(),
|
||||
buffers: &entity_vertex,
|
||||
},
|
||||
primitive: wgpu::PrimitiveState {
|
||||
cull_mode: None,
|
||||
..Default::default()
|
||||
},
|
||||
depth_stencil: Some(wgpu::DepthStencilState {
|
||||
format: wgpu::TextureFormat::Depth32Float,
|
||||
depth_write_enabled: Some(false),
|
||||
depth_compare: Some(wgpu::CompareFunction::LessEqual),
|
||||
stencil: Default::default(),
|
||||
bias: Default::default(),
|
||||
}),
|
||||
multisample: Default::default(),
|
||||
fragment: Some(wgpu::FragmentState {
|
||||
module: &entity_shader,
|
||||
entry_point: Some("fs_celestial"),
|
||||
compilation_options: Default::default(),
|
||||
targets: &[Some(wgpu::ColorTargetState {
|
||||
format: config.format.remove_srgb_suffix(),
|
||||
blend: Some(wgpu::BlendState {
|
||||
color: wgpu::BlendComponent {
|
||||
src_factor: wgpu::BlendFactor::SrcAlpha,
|
||||
dst_factor: wgpu::BlendFactor::One,
|
||||
operation: wgpu::BlendOperation::Add,
|
||||
},
|
||||
alpha: wgpu::BlendComponent {
|
||||
src_factor: wgpu::BlendFactor::SrcAlpha,
|
||||
dst_factor: wgpu::BlendFactor::One,
|
||||
operation: wgpu::BlendOperation::Add,
|
||||
},
|
||||
}),
|
||||
write_mask: wgpu::ColorWrites::ALL,
|
||||
})],
|
||||
}),
|
||||
multiview_mask: None,
|
||||
cache: None,
|
||||
});
|
||||
let celestial_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
|
||||
label: Some("Celestial bodies"),
|
||||
layout: Some(&entity_layout),
|
||||
@@ -795,6 +844,7 @@ impl Renderer {
|
||||
dark_disc,
|
||||
lines,
|
||||
entity_pipeline,
|
||||
additive_pipeline,
|
||||
celestial_pipeline,
|
||||
celestial_buffer,
|
||||
screen_pipelines,
|
||||
@@ -1311,15 +1361,18 @@ impl Renderer {
|
||||
.write_buffer(&self.outline, 0, bytemuck::cast_slice(&lines));
|
||||
}
|
||||
let mut combined;
|
||||
let all_entities: &[Vertex] = if frame.hand.is_empty() {
|
||||
let all_entities: &[Vertex] = if frame.hand.is_empty() && frame.additive.is_empty() {
|
||||
frame.entities
|
||||
} else {
|
||||
combined = Vec::with_capacity(frame.entities.len() + frame.hand.len());
|
||||
combined =
|
||||
Vec::with_capacity(frame.entities.len() + frame.additive.len() + frame.hand.len());
|
||||
combined.extend_from_slice(frame.entities);
|
||||
combined.extend_from_slice(frame.additive);
|
||||
combined.extend_from_slice(frame.hand);
|
||||
&combined
|
||||
};
|
||||
let hand_quads = (frame.hand.len() / 4) as u32;
|
||||
let additive_quads = (frame.additive.len() / 4) as u32;
|
||||
let entity_vertices = all_entities.len() as u64;
|
||||
if entity_vertices > self.entity_capacity {
|
||||
self.entity_capacity = entity_vertices.next_power_of_two();
|
||||
@@ -1342,9 +1395,9 @@ impl Renderer {
|
||||
bytemuck::cast_slice(&frame.celestial[..celestial_vertices]),
|
||||
);
|
||||
}
|
||||
let entity_quads = (entity_vertices / 4) as u32 - hand_quads;
|
||||
if entity_quads + hand_quads > self.index_quads {
|
||||
self.index_quads = (entity_quads + hand_quads).next_power_of_two();
|
||||
let entity_quads = (entity_vertices / 4) as u32 - hand_quads - additive_quads;
|
||||
if entity_quads + additive_quads + hand_quads > self.index_quads {
|
||||
self.index_quads = (entity_quads + additive_quads + hand_quads).next_power_of_two();
|
||||
self.indices = Self::quad_indices(&self.device, self.index_quads);
|
||||
}
|
||||
let view_target = surface_frame
|
||||
@@ -1437,6 +1490,13 @@ impl Renderer {
|
||||
pass.draw_indexed(0..entity_quads * 6, 0, 0..1);
|
||||
pass.set_bind_group(0, &self.group, &[]);
|
||||
}
|
||||
if additive_quads > 0 {
|
||||
pass.set_pipeline(&self.additive_pipeline);
|
||||
pass.set_bind_group(0, &self.entity_group, &[]);
|
||||
pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
|
||||
pass.draw_indexed(0..additive_quads * 6, (entity_quads * 4) as i32, 0..1);
|
||||
pass.set_bind_group(0, &self.group, &[]);
|
||||
}
|
||||
if outline_edges > 0 {
|
||||
pass.set_pipeline(&self.lines);
|
||||
pass.set_vertex_buffer(0, self.outline.slice(..));
|
||||
@@ -1484,7 +1544,11 @@ impl Renderer {
|
||||
pass.set_bind_group(0, &self.entity_group, &[]);
|
||||
pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
|
||||
pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
|
||||
pass.draw_indexed(0..hand_quads * 6, (entity_quads * 4) as i32, 0..1);
|
||||
pass.draw_indexed(
|
||||
0..hand_quads * 6,
|
||||
((entity_quads + additive_quads) * 4) as i32,
|
||||
0..1,
|
||||
);
|
||||
}
|
||||
if !frame.screen.is_empty() {
|
||||
let vertices: Vec<crate::screen_effects::ScreenVertex> =
|
||||
|
||||
@@ -333,7 +333,14 @@ pub fn layers(m: &Mob) -> Vec<Layer> {
|
||||
white,
|
||||
false,
|
||||
),
|
||||
S::Creeper if m.extra.charged => {}
|
||||
// EnergySwirlLayer (the scroll is not reproduced: atlas sprites do not wrap).
|
||||
S::Creeper if m.extra.charged => push(
|
||||
&mut v,
|
||||
"creeper#armor",
|
||||
"entity/creeper/creeper_armor",
|
||||
0x80FF_FFFF,
|
||||
true,
|
||||
),
|
||||
S::TropicalFish => {
|
||||
// TropicalFishPatternLayer: the pattern tinted with the pattern colour.
|
||||
let (model, letter, n) = if m.extra.variant < 6 {
|
||||
|
||||
@@ -41,7 +41,11 @@ impl Behaviours {
|
||||
}
|
||||
}
|
||||
/// `getHeightmapPos(MOTION_BLOCKING, pos)`.
|
||||
fn motion_blocking_top<L: LevelAccess + ?Sized>(&self, level: &L, pos: BlockPos) -> BlockPos {
|
||||
pub fn motion_blocking_top<L: LevelAccess + ?Sized>(
|
||||
&self,
|
||||
level: &L,
|
||||
pos: BlockPos,
|
||||
) -> BlockPos {
|
||||
let blocks = self.tag("minecraft:blocks_motion_in_heightmap");
|
||||
for y in (level.min_y()..level.max_y()).rev() {
|
||||
let state = level.block_state(BlockPos::new(pos.x, y, pos.z));
|
||||
|
||||
Reference in New Issue
Block a user