Shader packs, clean room 32: translucent entity parts and particles
A shader pack now draws particles with `gbuffers_particles` (falling back to `gbuffers_textured_lit`, `gbuffers_textured`, `gbuffers_basic`) and the entity parts that blend, a sneaking player's faded name tag and entity shadows, with `gbuffers_entities_translucent` (falling back to `gbuffers_entities`). Both blend with the translucent default unless `blend.*` says otherwise; particles keep vanilla's alpha cut at 0.1. Name tag text draws with `gbuffers_entities`, as cutout (2.3). Particles draw after deferred, with translucent terrain, unless `particles.ordering=before` or `particles.before.deferred=true`; translucent entities draw before deferred unless `separateEntityDraws=true` (3.2). Without a shader pack nothing changes. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -6784,12 +6784,10 @@ impl Game<'_> {
|
||||
self.fangs_geometry(camera, alpha, &mut out);
|
||||
let mut see_through = std::mem::take(&mut self.see_through_vertices);
|
||||
see_through.clear();
|
||||
// Name tags and shadows blend: Horizon keeps drawing them until the pack's entity
|
||||
// programs draw translucent parts (`minecraft:name_tag`, `minecraft:entity_shadow`).
|
||||
self.mark_stage(out.len(), "NONE");
|
||||
self.name_tag_geometry(camera, alpha, &mut out, &mut see_through);
|
||||
self.see_through_vertices = see_through;
|
||||
// Entity shadows (EntityRenderer.extractShadow).
|
||||
self.mark_translucent_entity(out.len(), "minecraft:entity_shadow");
|
||||
if let Some(sprite) = self.gui.atlas.sprites.get("misc/shadow").copied() {
|
||||
let ambient = if self.dim == Dim::Nether { 0.1 } else { 0.0 };
|
||||
let darken = self.sky_darken();
|
||||
|
||||
@@ -253,12 +253,16 @@ impl Game<'_> {
|
||||
const FADED: u32 = 0x7F;
|
||||
for tag in self.name_tags(camera, alpha) {
|
||||
let o = tag.at - camera;
|
||||
// `gbuffers_entities` draws name tag text (2.3); a sneaking player's faded tag, on its
|
||||
// background, blends.
|
||||
if tag.discrete {
|
||||
self.mark_translucent_entity(out.len(), "minecraft:name_tag");
|
||||
self.name_tag_quads(o, &tag.lines, FADED, true, 0, vertex_light(tag.light), out);
|
||||
continue;
|
||||
}
|
||||
// LightCoordsUtil.lightCoordsWithEmission(lightCoords, 2).
|
||||
let lit = (tag.light >> 4).max(2) << 4 | (tag.light & 15).max(2);
|
||||
self.mark_entity(out.len(), "minecraft:name_tag");
|
||||
self.name_tag_quads(o, &tag.lines, 0xFF, false, 0, vertex_light(lit), out);
|
||||
// RenderPipelines.TEXT_SEE_THROUGH: no depth test, no lightmap.
|
||||
self.name_tag_quads(o, &tag.lines, FADED, true, 2, 0, see_through);
|
||||
|
||||
@@ -146,9 +146,21 @@ impl Game<'_> {
|
||||
/// Starts a span of the entity geometry at vertex `start` for entity type `name`
|
||||
/// (`minecraft:zombie`; "" for one the pack cannot name). Nothing without a pack.
|
||||
pub(super) fn mark_entity(&self, start: usize, name: &str) {
|
||||
self.mark_entity_part(start, name, false);
|
||||
}
|
||||
|
||||
/// Starts a span for entity geometry that blends (name tags, shadows).
|
||||
pub(super) fn mark_translucent_entity(&self, start: usize, name: &str) {
|
||||
self.mark_entity_part(start, name, true);
|
||||
}
|
||||
|
||||
fn mark_entity_part(&self, start: usize, name: &str, translucent: bool) {
|
||||
if let Some(ids) = &self.pack_ids {
|
||||
let id = ids.entities.get(name).copied();
|
||||
self.push_span(start, "ENTITIES", id.unwrap_or(ids.missing_entity));
|
||||
if let Some(last) = self.entity_spans.borrow_mut().last_mut() {
|
||||
last.translucent = translucent;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -185,6 +197,7 @@ impl Game<'_> {
|
||||
start: start as u32,
|
||||
stage: horizon_shaders::render_stage(stage),
|
||||
id,
|
||||
translucent: false,
|
||||
};
|
||||
// A span that drew nothing gives way to the next.
|
||||
match spans.last_mut() {
|
||||
|
||||
@@ -16,6 +16,8 @@ pub struct EntitySpan {
|
||||
pub stage: u32,
|
||||
/// `entityId` for entities, `blockEntityId` for block entities (5.3), else 0.
|
||||
pub id: i32,
|
||||
/// An entity part that blends (a name tag, a shadow): `gbuffers_entities_translucent`.
|
||||
pub translucent: bool,
|
||||
}
|
||||
|
||||
/// `HzDraw`'s size: `renderStage`, `entityId`, `blockEntityId`, a pad, `entityColor`.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
//! Entities and block entities drawn by a shader pack's `gbuffers_entities` and `gbuffers_block`
|
||||
//! (spec 2.3, 5.3, 5.4): the runs of `Frame::entities` the game marked (`EntitySpan`), each its
|
||||
//! Entities, block entities, translucent entity parts and particles drawn by a shader pack's
|
||||
//! `gbuffers_entities`, `gbuffers_block`, `gbuffers_entities_translucent` and
|
||||
//! `gbuffers_particles` (spec 2.3, 5.3, 5.4): the runs of `Frame::entities` the game marked (`EntitySpan`), each its
|
||||
//! own draw with its `entityId` or `blockEntityId` and `entityColor` in a per-draw slot of
|
||||
//! `HzDraw` (set 2). Horizon draws whatever the pack does not.
|
||||
|
||||
@@ -125,8 +126,8 @@ pub(super) struct Draw {
|
||||
/// The first vertex.
|
||||
pub base: u32,
|
||||
pub quads: u32,
|
||||
/// `gbuffers_block` (or its fallback) draws it, not `gbuffers_entities`.
|
||||
pub block: bool,
|
||||
/// The program that draws it (`ENTITY`, `BLOCK`, `TRANSLUCENT`, `PARTICLE`).
|
||||
pub program: usize,
|
||||
pub slot: u32,
|
||||
}
|
||||
|
||||
@@ -253,7 +254,7 @@ impl PackEntities {
|
||||
layout: &wgpu::BindGroupLayout,
|
||||
entities: &[Vertex],
|
||||
spans: &[EntitySpan],
|
||||
drawn: [bool; 2],
|
||||
drawn: [bool; PROGRAMS],
|
||||
rest: &mut Vec<Vertex>,
|
||||
) {
|
||||
self.draws.clear();
|
||||
@@ -264,7 +265,7 @@ impl PackEntities {
|
||||
rest.extend_from_slice(&entities[..first.min(entities.len())]);
|
||||
for (span, range) in runs(entities.len(), spans) {
|
||||
let run = &entities[range];
|
||||
let Some(block) = drawn_by_pack(span.stage, drawn).filter(|_| plain(run)) else {
|
||||
let Some(program) = drawn_by_pack(&span, drawn).filter(|_| plain(run)) else {
|
||||
rest.extend_from_slice(run);
|
||||
continue;
|
||||
};
|
||||
@@ -273,7 +274,10 @@ impl PackEntities {
|
||||
}
|
||||
let start = self.scratch.len() as u32;
|
||||
self.scratch.extend_from_slice(run);
|
||||
let (entity_id, block_id) = if block { (0, span.id) } else { (span.id, 0) };
|
||||
let (entity_id, block_id) = match program {
|
||||
BLOCK => (0, span.id),
|
||||
_ => (span.id, 0),
|
||||
};
|
||||
let mut bytes = [0u8; SLOT as usize];
|
||||
bytes[0..4].copy_from_slice(&(span.stage as i32).to_le_bytes());
|
||||
bytes[4..8].copy_from_slice(&entity_id.to_le_bytes());
|
||||
@@ -287,7 +291,7 @@ impl PackEntities {
|
||||
self.draws.push(Draw {
|
||||
base: start,
|
||||
quads: run.len() as u32 / 4,
|
||||
block,
|
||||
program,
|
||||
slot: self.draws.len() as u32,
|
||||
});
|
||||
}
|
||||
@@ -340,16 +344,30 @@ fn plain(run: &[Vertex]) -> bool {
|
||||
.all(|v| !matches!(v.layer, 2 | 4 | 6 | 9 | 10 | 11 | 12))
|
||||
}
|
||||
|
||||
/// Whether the pack draws a run of render stage `stage` (`Some(true)` with `gbuffers_block`),
|
||||
/// given which of `gbuffers_entities` and `gbuffers_block` (or their fallbacks) it has.
|
||||
pub fn drawn_by_pack(stage: u32, drawn: [bool; 2]) -> Option<bool> {
|
||||
if stage == render_stage("ENTITIES") && drawn[0] {
|
||||
Some(false)
|
||||
} else if stage == render_stage("BLOCK_ENTITIES") && drawn[1] {
|
||||
Some(true)
|
||||
/// The programs of entity runs, in the order they draw.
|
||||
pub const ENTITY: usize = 0;
|
||||
pub const BLOCK: usize = 1;
|
||||
pub const TRANSLUCENT: usize = 2;
|
||||
pub const PARTICLE: usize = 3;
|
||||
pub const PROGRAMS: usize = 4;
|
||||
|
||||
/// Which program draws `span`'s run, given which of them (or their fallbacks) the pack has;
|
||||
/// `None`: Horizon draws it.
|
||||
pub fn drawn_by_pack(span: &EntitySpan, drawn: [bool; PROGRAMS]) -> Option<usize> {
|
||||
let program = if span.stage == render_stage("ENTITIES") {
|
||||
if span.translucent {
|
||||
TRANSLUCENT
|
||||
} else {
|
||||
ENTITY
|
||||
}
|
||||
} else if span.stage == render_stage("BLOCK_ENTITIES") {
|
||||
BLOCK
|
||||
} else if span.stage == render_stage("PARTICLES") {
|
||||
PARTICLE
|
||||
} else {
|
||||
None
|
||||
}
|
||||
return None;
|
||||
};
|
||||
drawn[program].then_some(program)
|
||||
}
|
||||
|
||||
/// Each span with its vertex range: from its start to the next span's (or the end).
|
||||
@@ -378,6 +396,7 @@ mod tests {
|
||||
start,
|
||||
stage: render_stage(stage),
|
||||
id,
|
||||
translucent: false,
|
||||
};
|
||||
let spans = [
|
||||
span(2, "ENTITIES", 7),
|
||||
@@ -386,10 +405,18 @@ mod tests {
|
||||
];
|
||||
let ranges: Vec<_> = runs(10, &spans).map(|(_, r)| r).collect();
|
||||
assert_eq!(ranges, [2..5, 5..6, 6..10]);
|
||||
assert_eq!(drawn_by_pack(spans[0].stage, [true, false]), Some(false));
|
||||
assert_eq!(drawn_by_pack(spans[1].stage, [true, true]), None);
|
||||
assert_eq!(drawn_by_pack(spans[2].stage, [true, false]), None);
|
||||
assert_eq!(drawn_by_pack(spans[2].stage, [false, true]), Some(true));
|
||||
let all = [true; PROGRAMS];
|
||||
assert_eq!(drawn_by_pack(&spans[0], all), Some(ENTITY));
|
||||
assert_eq!(drawn_by_pack(&spans[1], all), Some(PARTICLE));
|
||||
assert_eq!(drawn_by_pack(&spans[1], [true, true, true, false]), None);
|
||||
assert_eq!(drawn_by_pack(&spans[2], [true, false, true, true]), None);
|
||||
assert_eq!(drawn_by_pack(&spans[2], all), Some(BLOCK));
|
||||
let shadow = EntitySpan {
|
||||
translucent: true,
|
||||
..spans[0]
|
||||
};
|
||||
assert_eq!(drawn_by_pack(&shadow, all), Some(TRANSLUCENT));
|
||||
assert_eq!(drawn_by_pack(&span(0, "DESTROY", 0), all), None);
|
||||
// A beacon beam's quads stay Horizon's.
|
||||
assert!(plain(&[v(0), v(0), v(0), v(0), v(1)]));
|
||||
assert!(!plain(&[v(0), v(0), v(0), v(0), v(6)]));
|
||||
|
||||
@@ -16,7 +16,7 @@ use std::collections::HashMap;
|
||||
use horizon_shaders::{Format, Group, Kind, Post, Val};
|
||||
|
||||
use super::pack_draw::DrawUniforms;
|
||||
use super::pack_entities::PackEntities;
|
||||
use super::pack_entities::{PROGRAMS, PackEntities};
|
||||
use super::pack_sky::PackSky;
|
||||
use super::pack_uniforms::{self, FrameUniforms, PackInputs};
|
||||
|
||||
@@ -131,12 +131,13 @@ struct Sky {
|
||||
textured: Option<Pass>,
|
||||
}
|
||||
|
||||
/// Entities and block entities a pack draws (`gbuffers_entities`, `gbuffers_block` or their
|
||||
/// fallbacks), after terrain; Horizon draws the others.
|
||||
/// Entities, block entities, translucent entity parts and particles a pack draws
|
||||
/// (`pack_entities::ENTITY`... order), after terrain or, `late`, after deferred; Horizon draws
|
||||
/// the others.
|
||||
struct Entities {
|
||||
geometry: PackEntities,
|
||||
entity: Option<Pass>,
|
||||
block: Option<Pass>,
|
||||
passes: [Option<Pass>; PROGRAMS],
|
||||
late: [bool; PROGRAMS],
|
||||
}
|
||||
|
||||
struct Pass {
|
||||
@@ -912,7 +913,16 @@ impl PackPost {
|
||||
}
|
||||
});
|
||||
let sky = sky.filter(|s| s.basic.is_some() || s.textured.is_some());
|
||||
let entity_vertices = (post.entities.is_some() || post.block.is_some())
|
||||
let programs = [
|
||||
post.entities,
|
||||
post.block,
|
||||
post.entities_translucent,
|
||||
post.particles,
|
||||
];
|
||||
let late = [false, false, post.translucent_late, post.particles_late];
|
||||
let entity_vertices = programs
|
||||
.iter()
|
||||
.any(Option::is_some)
|
||||
.then(|| PackEntities::new(device, &draws.layout));
|
||||
let entity_buffers = super::pack_entities::buffers();
|
||||
let entity_geometry = entity_vertices.as_ref().map(|e| Geometry {
|
||||
@@ -923,16 +933,16 @@ impl PackPost {
|
||||
ids: None,
|
||||
cull: false,
|
||||
});
|
||||
let entity = post.entities.zip(entity_geometry.as_ref());
|
||||
let entity = entity.and_then(|(p, g)| build(p, Some(g)));
|
||||
let block = post.block.zip(entity_geometry.as_ref());
|
||||
let block = block.and_then(|(p, g)| build(p, Some(g)));
|
||||
let entity_passes = programs.map(|p| {
|
||||
p.zip(entity_geometry.as_ref())
|
||||
.and_then(|(p, g)| build(p, Some(g)))
|
||||
});
|
||||
let entities = entity_vertices
|
||||
.filter(|_| entity.is_some() || block.is_some())
|
||||
.filter(|_| entity_passes.iter().any(Option::is_some))
|
||||
.map(|geometry| Entities {
|
||||
geometry,
|
||||
entity,
|
||||
block,
|
||||
passes: entity_passes,
|
||||
late,
|
||||
});
|
||||
// Developers' aid: `HORIZON_SHADER_PACK_SKIP=composite,final` leaves programs out.
|
||||
let skip = std::env::var("HORIZON_SHADER_PACK_SKIP").unwrap_or_default();
|
||||
@@ -956,10 +966,13 @@ impl PackPost {
|
||||
notes.push(format!("the {part} draw with {}", p.name));
|
||||
}
|
||||
}
|
||||
for (part, pass) in entities
|
||||
.iter()
|
||||
.flat_map(|e| [("entities", &e.entity), ("block entities", &e.block)])
|
||||
{
|
||||
let parts = [
|
||||
"entities",
|
||||
"block entities",
|
||||
"translucent entities",
|
||||
"particles",
|
||||
];
|
||||
for (part, pass) in entities.iter().flat_map(|e| parts.iter().zip(&e.passes)) {
|
||||
if let Some(p) = pass {
|
||||
notes.push(format!("{part} draw with {}", p.name));
|
||||
}
|
||||
@@ -981,11 +994,7 @@ impl PackPost {
|
||||
.iter()
|
||||
.flat_map(|s| s.basic.iter().chain(&s.textured))
|
||||
.chain(&terrain)
|
||||
.chain(
|
||||
entities
|
||||
.iter()
|
||||
.flat_map(|e| e.entity.iter().chain(&e.block)),
|
||||
)
|
||||
.chain(entities.iter().flat_map(|e| e.passes.iter().flatten()))
|
||||
.chain(&water)
|
||||
.find(touched)
|
||||
.map(|_| true)
|
||||
@@ -1420,7 +1429,8 @@ impl PackPost {
|
||||
self.sky = Some(sky);
|
||||
}
|
||||
|
||||
/// Entities and block entities with the pack's programs: each run `prepare_entities` kept
|
||||
/// Entities, block entities, translucent entity parts and particles with the pack's
|
||||
/// programs, those drawn before deferred or (`late`) after: each run `prepare_entities` kept
|
||||
/// is one draw with its own `entityId` or `blockEntityId` and `entityColor`.
|
||||
fn draw_entities(
|
||||
&mut self,
|
||||
@@ -1428,17 +1438,20 @@ impl PackPost {
|
||||
queue: &wgpu::Queue,
|
||||
encoder: &mut wgpu::CommandEncoder,
|
||||
size: [u32; 2],
|
||||
late: bool,
|
||||
) {
|
||||
let Some(mut entities) = self.entities.take() else {
|
||||
return;
|
||||
};
|
||||
let geometry = &entities.geometry;
|
||||
for (block, pass) in [(false, &mut entities.entity), (true, &mut entities.block)] {
|
||||
let Some(pass) = pass else { continue };
|
||||
for (program, pass) in entities.passes.iter_mut().enumerate() {
|
||||
let Some(pass) = pass.as_mut().filter(|_| entities.late[program] == late) else {
|
||||
continue;
|
||||
};
|
||||
let mut draws = geometry
|
||||
.draws
|
||||
.iter()
|
||||
.filter(|d| d.block == block)
|
||||
.filter(|d| d.program == program)
|
||||
.peekable();
|
||||
if draws.peek().is_none() {
|
||||
continue;
|
||||
@@ -1478,7 +1491,7 @@ impl PackPost {
|
||||
rest.extend_from_slice(entities);
|
||||
return;
|
||||
};
|
||||
let drawn = [e.entity.is_some(), e.block.is_some()];
|
||||
let drawn = e.passes.each_ref().map(Option::is_some);
|
||||
e.geometry.prepare(
|
||||
device,
|
||||
queue,
|
||||
@@ -1509,7 +1522,20 @@ impl PackPost {
|
||||
self.draw_sky(device, queue, encoder, size, frame);
|
||||
}
|
||||
self.draw_terrain(device, queue, encoder, size, false, terrain);
|
||||
self.draw_entities(device, queue, encoder, size);
|
||||
self.draw_entities(device, queue, encoder, size, false);
|
||||
}
|
||||
|
||||
/// Translucent terrain, then the entity parts drawn after deferred.
|
||||
fn draw_translucent(
|
||||
&mut self,
|
||||
device: &wgpu::Device,
|
||||
queue: &wgpu::Queue,
|
||||
encoder: &mut wgpu::CommandEncoder,
|
||||
size: [u32; 2],
|
||||
terrain: &mut TerrainDraw<'_>,
|
||||
) {
|
||||
self.draw_terrain(device, queue, encoder, size, true, terrain);
|
||||
self.draw_entities(device, queue, encoder, size, true);
|
||||
}
|
||||
|
||||
/// Regenerates the mip chain of buffer `b`'s side that programs read.
|
||||
@@ -1818,7 +1844,13 @@ impl PackPost {
|
||||
let mut shown = false;
|
||||
let mut terrain_drawn =
|
||||
self.terrain.is_none() && self.sky.is_none() && self.entities.is_none();
|
||||
let mut water_drawn = self.water.is_none();
|
||||
let late_entities = self.entities.as_ref().is_some_and(|e| {
|
||||
e.passes
|
||||
.iter()
|
||||
.zip(e.late)
|
||||
.any(|(p, late)| p.is_some() && late)
|
||||
});
|
||||
let mut water_drawn = self.water.is_none() && !late_entities;
|
||||
for pass in &mut passes {
|
||||
if !terrain_drawn && pass.group != Group::Prepare {
|
||||
terrain_drawn = true;
|
||||
@@ -1826,7 +1858,7 @@ impl PackPost {
|
||||
}
|
||||
if !water_drawn && matches!(pass.group, Group::Composite | Group::Final) {
|
||||
water_drawn = true;
|
||||
self.draw_terrain(device, queue, encoder, size, true, terrain);
|
||||
self.draw_translucent(device, queue, encoder, size, terrain);
|
||||
}
|
||||
if pass.group == Group::Deferred && !seen.0 {
|
||||
seen.0 = true;
|
||||
@@ -1881,7 +1913,7 @@ impl PackPost {
|
||||
self.draw_opaque(device, queue, encoder, size, frame, terrain);
|
||||
}
|
||||
if !water_drawn {
|
||||
self.draw_terrain(device, queue, encoder, size, true, terrain);
|
||||
self.draw_translucent(device, queue, encoder, size, terrain);
|
||||
}
|
||||
let targets = self.targets.as_ref().expect("resized");
|
||||
let view = |m: u16, i: usize, alt: bool| {
|
||||
|
||||
@@ -120,6 +120,23 @@ const BLOCK: [&str; 5] = [
|
||||
"gbuffers_basic",
|
||||
];
|
||||
|
||||
/// `gbuffers_entities_translucent` and its fallbacks (2.3).
|
||||
const ENTITIES_TRANSLUCENT: [&str; 5] = [
|
||||
"gbuffers_entities_translucent",
|
||||
"gbuffers_entities",
|
||||
"gbuffers_textured_lit",
|
||||
"gbuffers_textured",
|
||||
"gbuffers_basic",
|
||||
];
|
||||
|
||||
/// `gbuffers_particles` and its fallbacks (2.3).
|
||||
const PARTICLES: [&str; 4] = [
|
||||
"gbuffers_particles",
|
||||
"gbuffers_textured_lit",
|
||||
"gbuffers_textured",
|
||||
"gbuffers_basic",
|
||||
];
|
||||
|
||||
/// The sun and moon's default blend: added to the sky, as vanilla draws them.
|
||||
pub const CELESTIAL_BLEND: Blend = [
|
||||
Factor::SrcAlpha,
|
||||
@@ -170,6 +187,14 @@ pub struct Post {
|
||||
pub entities: Option<PostProgram>,
|
||||
/// What draws block entities, after terrain.
|
||||
pub block: Option<PostProgram>,
|
||||
/// What draws translucent entities (name tags, shadows), after the others.
|
||||
pub entities_translucent: Option<PostProgram>,
|
||||
/// What draws particles.
|
||||
pub particles: Option<PostProgram>,
|
||||
/// Translucent entities draw after deferred (`separateEntityDraws`, 3.2).
|
||||
pub translucent_late: bool,
|
||||
/// Particles draw after deferred (`particles.ordering`, `particles.before.deferred`, 3.2).
|
||||
pub particles_late: bool,
|
||||
/// The custom uniforms of `shaders.properties` (3.4).
|
||||
pub custom: Custom,
|
||||
pub config: Config,
|
||||
@@ -219,6 +244,10 @@ pub fn load_post(
|
||||
sky_textured: None,
|
||||
entities: None,
|
||||
block: None,
|
||||
entities_translucent: None,
|
||||
particles: None,
|
||||
translucent_late: false,
|
||||
particles_late: false,
|
||||
custom: Custom::parse(properties),
|
||||
config: Config::default(),
|
||||
notes: Vec::new(),
|
||||
@@ -293,6 +322,26 @@ pub fn load_post(
|
||||
),
|
||||
None => (None, None),
|
||||
};
|
||||
// Translucent entities and particles blend (OQ-23). Particles keep vanilla's alpha cut at
|
||||
// 0.1; translucent entities lose only fully transparent texels (a shadow fades out).
|
||||
let translucent =
|
||||
|names: &[&str],
|
||||
cut: f32,
|
||||
gbuffers: &mut dyn FnMut(&[&str], &GbuffersInputs) -> Option<PostProgram>| {
|
||||
let i = inputs.entities.as_ref()?;
|
||||
let mut i = i.clone();
|
||||
i.alpha_test = Some(crate::AlphaTest {
|
||||
op: ">",
|
||||
reference: cut,
|
||||
});
|
||||
gbuffers(names, &i).map(|mut p| {
|
||||
p.blend = blend(properties, &p.name).unwrap_or(Some(TRANSLUCENT_BLEND));
|
||||
p
|
||||
})
|
||||
};
|
||||
let mut gbuffers_dyn = |names: &[&str], i: &GbuffersInputs| gbuffers(names, Group::Gbuffers, i);
|
||||
let entities_translucent = translucent(&ENTITIES_TRANSLUCENT, 0.0, &mut gbuffers_dyn);
|
||||
let particles = translucent(&PARTICLES, 0.1, &mut gbuffers_dyn);
|
||||
if let Some(inputs) = &inputs.terrain {
|
||||
let terrain = gbuffers(&TERRAIN, Group::Gbuffers, inputs);
|
||||
// gbuffers_water falls back to gbuffers_terrain's chain (2.3).
|
||||
@@ -310,6 +359,17 @@ pub fn load_post(
|
||||
loader.post.sky_textured = sky_textured;
|
||||
loader.post.entities = entities;
|
||||
loader.post.block = block;
|
||||
loader.post.entities_translucent = entities_translucent;
|
||||
loader.post.particles = particles;
|
||||
let flag = |key: &str| properties.get(key).map(|v| v.trim() == "true");
|
||||
loader.post.translucent_late = flag("separateEntityDraws").unwrap_or(false);
|
||||
// `after` when the pack has a deferred program, else `mixed`; ours are all translucent, so
|
||||
// `mixed` draws them after deferred too.
|
||||
loader.post.particles_late = match properties.get("particles.ordering").map(str::trim) {
|
||||
Some("before") => false,
|
||||
Some(_) => true,
|
||||
None => !flag("particles.before.deferred").unwrap_or(false),
|
||||
};
|
||||
post.config = std::mem::take(&mut post.config).finish();
|
||||
post
|
||||
}
|
||||
@@ -624,6 +684,24 @@ mod tests {
|
||||
(block.name.as_str(), block.blend),
|
||||
("gbuffers_terrain", None)
|
||||
);
|
||||
// Translucent entity parts and particles blend; particles draw after deferred unless
|
||||
// the pack says otherwise, translucent entities before unless `separateEntityDraws`.
|
||||
let (translucent, particles) = (
|
||||
post.entities_translucent.as_ref().unwrap(),
|
||||
post.particles.as_ref().unwrap(),
|
||||
);
|
||||
assert_eq!(
|
||||
(translucent.name.as_str(), translucent.blend),
|
||||
("gbuffers_textured", Some(TRANSLUCENT_BLEND))
|
||||
);
|
||||
assert_eq!(particles.blend, Some(TRANSLUCENT_BLEND));
|
||||
assert!(post.particles_late && !post.translucent_late);
|
||||
let ordering = Properties::parse(
|
||||
"particles.ordering = before\nseparateEntityDraws = true\n",
|
||||
¯os,
|
||||
);
|
||||
let post = load_post(&pack, "", &ordering, ¯os, &inputs);
|
||||
assert!(!post.particles_late && post.translucent_late);
|
||||
let properties = Properties::parse(
|
||||
"blend.gbuffers_terrain = ONE ONE ZERO ONE\nblend.gbuffers_water = off\n",
|
||||
¯os,
|
||||
|
||||
Reference in New Issue
Block a user