heaust/yawn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: synthesize default graph attachments

Browse Source 
Amp-Thread-ID: https://ampcode.com/threads/T-019f9d91-77c1-7206-a60f-ed6554ce92ab

Co-authored-by: Heaust Azure <heaust.azure@gmail.com>
This commit is contained in:
Amp
2026-07-28 23:08:26 +00:00
co-authored by heaust
parent f6d6af7a17
commit eb640f0183
10 changed files with 1363 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files
renderer/src/render_graph/compiler.rs
+469 -148
View File
@@ -136,6 +136,14 @@ fn color(value: [f32; 4], min: f32, max: f32, base: &str) -> Result<[f32; 3], Gr
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
struct OutputKey(usize, u16);
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
enum TransitionTargetKey {
Authored(OutputKey),
CompilerDefaultInput {
owner_node: usize,
input_ordinal: u16,
},
}
#[derive(Clone, Copy)]
struct BoundInput {
producer: OutputKey,
@@ -155,7 +163,7 @@ struct DependencyEdge {
struct TextureTransition {
writer_node: usize,
input_socket: &'static str,
target: OutputKey,
target: TransitionTargetKey,
output: OutputKey,
}
@@ -164,11 +172,74 @@ enum ResolvedTransition {
Resolved {
family: u32,
version: u32,
target: OutputKey,
target: TransitionTargetKey,
},
Cyclic,
}
#[derive(Clone)]
struct DefaultDraft {
key: TransitionTargetKey,
resource: u32,
family: u32,
owner_node: usize,
input_ordinal: u16,
socket: &'static str,
role: CompilerTextureRole,
format: TextureFormat,
descriptor: DraftDescriptor,
}
#[derive(Clone)]
enum DraftDescriptor {
Deferred,
Known(NormalizedTextureDescriptor),
}
enum SampledDescriptor<'a> {
Known(&'a NormalizedTextureDescriptor),
Deferred,
Unproduced,
}
fn known_family_descriptor<'a>(
family: u32,
authored_families: &'a [TextureFamily],
drafts: &'a [DefaultDraft],
) -> Option<&'a NormalizedTextureDescriptor> {
if let Some(family) = authored_families.get(family as usize) {
return Some(family_descriptor(family));
}
let draft = drafts.get(family as usize - authored_families.len())?;
match &draft.descriptor {
DraftDescriptor::Known(descriptor) => Some(descriptor),
DraftDescriptor::Deferred => None,
}
}
fn sampled_descriptor<'a>(
key: OutputKey,
version_of: &HashMap<OutputKey, (u32, u32, u32)>,
resolved: &HashMap<OutputKey, ResolvedTransition>,
authored_families: &'a [TextureFamily],
drafts: &'a [DefaultDraft],
) -> Result<SampledDescriptor<'a>, GraphError> {
if let Some(&(family, _, _)) = version_of.get(&key) {
return Ok(known_family_descriptor(family, authored_families, drafts)
.map(SampledDescriptor::Known)
.unwrap_or(SampledDescriptor::Deferred));
}
match resolved.get(&key) {
Some(ResolvedTransition::Cyclic) => Ok(SampledDescriptor::Deferred),
Some(ResolvedTransition::Resolved { .. }) => Err(error(
"GRAPH_RESOURCE_VERSION_INVALID",
"resolved texture has no version",
"resources",
)),
None => Ok(SampledDescriptor::Unproduced),
}
}
fn reaches(
from: usize,
to: usize,
@@ -1037,7 +1108,12 @@ pub fn compile(graph: Graph) -> Result<CompiledGraph, GraphError> {
}
}
}
let all_outputs: usize = contracts.iter().map(|c| c.outputs.len()).sum();
let all_outputs: usize = contracts
.iter()
.flat_map(|contract| contract.outputs)
.filter(|output| !output.semantic_type.is_virtual())
.count();
let authored_materialized_output_count = output_ids.len();
// Establish families and transitions without relying on a schedule.
let mut families = Vec::new();
@@ -1054,7 +1130,7 @@ pub fn compile(graph: Graph) -> Result<CompiledGraph, GraphError> {
} => {
let id = families.len() as u32;
let r = source.unwrap();
source_family.insert(OutputKey(i, 0), id);
source_family.insert(TransitionTargetKey::Authored(OutputKey(i, 0)), id);
families.push(TextureFamily {
id,
key: TextureFamilyKey {
@@ -1079,8 +1155,72 @@ pub fn compile(graph: Graph) -> Result<CompiledGraph, GraphError> {
_ => {}
}
}
// Reserve compiler-owned roots without exposing incomplete public plan entries.
// IDs remain stable while effective families and descriptors are resolved.
let full_extent = NormalizedTextureExtent::SurfaceRelative {
width: Ratio {
numerator: 1,
denominator: 1,
},
height: Ratio {
numerator: 1,
denominator: 1,
},
depth_or_array_layers: 1,
};
let authored_family_count = families.len();
let mut default_roots: Vec<DefaultDraft> = Vec::new();
let mut default_targets = HashMap::new();
for i in 0..graph.nodes.len() {
if !live.contains(&i) || contracts[i].key != "pipeline" {
continue;
}
for (input_ordinal, (socket, role, format, opposite)) in [
(
"colorTarget",
CompilerTextureRole::ColorTarget,
TextureFormat::Rgba16Float,
"depthTarget",
),
(
"depthTarget",
CompilerTextureRole::DepthTarget,
TextureFormat::Depth32Float,
"colorTarget",
),
]
.into_iter()
.enumerate()
{
if bound[i].contains_key(socket) {
continue;
}
let input_ordinal = input_ordinal as u16 + 2;
let key = TransitionTargetKey::CompilerDefaultInput {
owner_node: i,
input_ordinal,
};
let resource = (authored_materialized_output_count + default_roots.len()) as u32;
let family = (authored_family_count + default_roots.len()) as u32;
default_targets.insert((i, socket), key);
source_family.insert(key, family);
let _ = opposite;
default_roots.push(DefaultDraft {
key,
resource,
family,
owner_node: i,
input_ordinal,
socket,
role,
format,
descriptor: DraftDescriptor::Deferred,
});
}
}
let mut transitions: Vec<TextureTransition> = Vec::new();
let mut transitions_by_target: BTreeMap<OutputKey, Vec<usize>> = BTreeMap::new();
let mut transitions_by_target: BTreeMap<TransitionTargetKey, Vec<usize>> = BTreeMap::new();
for i in 0..graph.nodes.len() {
if !live.contains(&i) {
continue;
@@ -1094,7 +1234,10 @@ pub fn compile(graph: Graph) -> Result<CompiledGraph, GraphError> {
let transition = TextureTransition {
writer_node: i,
input_socket,
target: bound[i][input_socket].producer,
target: bound[i]
.get(input_socket)
.map(|b| TransitionTargetKey::Authored(b.producer))
.unwrap_or_else(|| default_targets[&(i, input_socket)]),
output: OutputKey(i, output_ordinal),
};
let index = transitions.len();
@@ -1110,7 +1253,7 @@ pub fn compile(graph: Graph) -> Result<CompiledGraph, GraphError> {
output: OutputKey,
transitions: &[TextureTransition],
transition_for_output: &HashMap<OutputKey, usize>,
source_family: &HashMap<OutputKey, u32>,
source_family: &HashMap<TransitionTargetKey, u32>,
colors: &mut HashMap<OutputKey, u8>,
resolved: &mut HashMap<OutputKey, ResolvedTransition>,
) -> ResolvedTransition {
@@ -1128,23 +1271,27 @@ pub fn compile(graph: Graph) -> Result<CompiledGraph, GraphError> {
version: 0,
target: transition.target,
}
} else if transition_for_output.contains_key(&transition.target) {
match resolve_transition(
transition.target,
transitions,
transition_for_output,
source_family,
colors,
resolved,
) {
ResolvedTransition::Resolved {
family, version, ..
} => ResolvedTransition::Resolved {
family,
version: version + 1,
target: transition.target,
},
ResolvedTransition::Cyclic => ResolvedTransition::Cyclic,
} else if let TransitionTargetKey::Authored(target_output) = transition.target {
if !transition_for_output.contains_key(&target_output) {
ResolvedTransition::Cyclic
} else {
match resolve_transition(
target_output,
transitions,
transition_for_output,
source_family,
colors,
resolved,
) {
ResolvedTransition::Resolved {
family, version, ..
} => ResolvedTransition::Resolved {
family,
version: version + 1,
target: transition.target,
},
ResolvedTransition::Cyclic => ResolvedTransition::Cyclic,
}
}
} else {
ResolvedTransition::Cyclic
@@ -1179,7 +1326,16 @@ pub fn compile(graph: Graph) -> Result<CompiledGraph, GraphError> {
target,
} = resolved[&transition.output]
{
let target_id = output_ids[&target];
let target_id = match target {
TransitionTargetKey::Authored(key) => output_ids[&key],
TransitionTargetKey::CompilerDefaultInput { .. } => {
default_roots
.iter()
.find(|root| root.key == target)
.unwrap()
.resource
}
};
version_of.insert(transition.output, (family, version, target_id));
}
}
@@ -1217,7 +1373,8 @@ pub fn compile(graph: Graph) -> Result<CompiledGraph, GraphError> {
if !version_of.contains_key(&key) {
continue;
}
let Some(next_indices) = transitions_by_target.get(&key) else {
let Some(next_indices) = transitions_by_target.get(&TransitionTargetKey::Authored(key))
else {
continue;
};
let [next_index] = next_indices.as_slice() else {
@@ -1249,7 +1406,9 @@ pub fn compile(graph: Graph) -> Result<CompiledGraph, GraphError> {
continue;
}
if contracts[i].key == "pipeline" {
if bound[i]["colorTarget"].producer == bound[i]["depthTarget"].producer
if bound[i].get("colorTarget").map(|b| b.producer)
== bound[i].get("depthTarget").map(|b| b.producer)
&& bound[i].contains_key("colorTarget")
|| matches!((version_of.get(&OutputKey(i, 0)), version_of.get(&OutputKey(i, 1))), (Some((cf, _, _)), Some((df, _, _))) if cf == df)
{
return Err(error(
@@ -1286,32 +1445,48 @@ pub fn compile(graph: Graph) -> Result<CompiledGraph, GraphError> {
}
}
// Materialize versions only after hazard and writer precedence has been settled.
for transition in &transitions {
if let Some(&(family, version, target)) = version_of.get(&transition.output) {
families[family as usize].versions.push(TextureVersion {
version,
resource: output_ids[&transition.output],
target,
initialized: true,
stored: true,
lifetime: Lifetime {
first_use: 0,
last_use: 0,
},
});
}
}
for family in &mut families {
family.versions.sort_by_key(|version| version.version);
for (index, version) in family.versions.iter().enumerate() {
if version.version != index as u32 {
return Err(error(
"GRAPH_RESOURCE_VERSION_INVALID",
"texture versions must form a dense linear chain",
"resources",
));
// Infer draft descriptors without recursion. Unknown and invalid dependencies
// remain deferred so descriptor diagnostics never steal cycle diagnostics.
for _ in 0..default_roots.len() {
let mut changed = false;
for index in 0..default_roots.len() {
if matches!(default_roots[index].descriptor, DraftDescriptor::Known(_)) {
continue;
}
let owner = default_roots[index].owner_node;
let opposite_output = if default_roots[index].role == CompilerTextureRole::ColorTarget {
OutputKey(owner, 1)
} else {
OutputKey(owner, 0)
};
let Some(&(opposite_family, _, _)) = version_of.get(&opposite_output) else {
continue;
};
let extent = if opposite_family as usize >= authored_family_count
&& default_roots
.get(opposite_family as usize - authored_family_count)
.is_some_and(|draft| draft.owner_node == owner)
{
Some(full_extent.clone())
} else {
known_family_descriptor(opposite_family, &families, &default_roots)
.map(|descriptor| descriptor.extent.clone())
};
if let Some(extent) = extent {
default_roots[index].descriptor =
DraftDescriptor::Known(NormalizedTextureDescriptor {
dimension: TextureDimension::D2,
format: default_roots[index].format,
extent,
mip_level_count: 1,
sample_count: 1,
view_formats: vec![],
});
changed = true;
}
}
if !changed {
break;
}
}
@@ -1320,102 +1495,146 @@ pub fn compile(graph: Graph) -> Result<CompiledGraph, GraphError> {
if !live.contains(&i) || contracts[i].key != "pipeline" {
continue;
}
let (Some(&(cf, _, _)), Some(&(df, _, _))) = (
version_of.get(&OutputKey(i, 0)),
version_of.get(&OutputKey(i, 1)),
) else {
continue;
};
let TextureFamilySource::AuthoredTexture { descriptor: cd, .. } =
&families[cf as usize].source;
let TextureFamilySource::AuthoredTexture { descriptor: dd, .. } =
&families[df as usize].source;
let ok_depth = dd.dimension == TextureDimension::D2
&& dd.format == TextureFormat::Depth32Float
&& dd.sample_count == 1
&& extent_layers(&dd.extent) == 1;
let ok_color = cd.format != TextureFormat::Depth32Float
&& cd.dimension == dd.dimension
&& cd.extent == dd.extent
&& cd.sample_count == 1;
if !ok_depth || !ok_color {
let cd = version_of
.get(&OutputKey(i, 0))
.and_then(|&(family, _, _)| known_family_descriptor(family, &families, &default_roots));
let dd = version_of
.get(&OutputKey(i, 1))
.and_then(|&(family, _, _)| known_family_descriptor(family, &families, &default_roots));
let ok_depth = dd.is_none_or(|dd| {
dd.dimension == TextureDimension::D2
&& dd.format == TextureFormat::Depth32Float
&& dd.sample_count == 1
&& dd.mip_level_count == 1
&& dd.view_formats.is_empty()
&& extent_layers(&dd.extent) == 1
});
let ok_color = cd.is_none_or(|cd| {
cd.dimension == TextureDimension::D2
&& cd.format != TextureFormat::Depth32Float
&& cd.sample_count == 1
&& cd.mip_level_count == 1
&& cd.view_formats.is_empty()
&& extent_layers(&cd.extent) == 1
});
if !ok_color {
return Err(error(
"GRAPH_ILLEGAL_ACCESS",
"attachments are incompatible",
format!("nodes[{i}].inputs"),
"color attachment is invalid",
format!("nodes[{i}].inputs.colorTarget"),
));
}
if !ok_depth {
return Err(error(
"GRAPH_ILLEGAL_ACCESS",
"depth attachment is invalid",
format!("nodes[{i}].inputs.depthTarget"),
));
}
if let (Some(cd), Some(dd)) = (cd, dd) {
if cd.dimension != dd.dimension
|| cd.extent != dd.extent
|| cd.sample_count != dd.sample_count
{
return Err(error(
"GRAPH_ILLEGAL_ACCESS",
"attachments are incompatible",
format!("nodes[{i}].inputs"),
));
}
}
}
for i in 0..graph.nodes.len() {
if !live.contains(&i) || contracts[i].fullscreen_policy.is_none() {
continue;
}
let source_key = bound[i]["source"].producer;
let Some(&(source_family_id, _, _)) = version_of.get(&source_key) else {
let source = sampled_descriptor(
bound[i]["source"].producer,
&version_of,
&resolved,
&families,
&default_roots,
)?;
let source_descriptor = match source {
SampledDescriptor::Known(descriptor) => Some(descriptor),
SampledDescriptor::Deferred | SampledDescriptor::Unproduced => None,
};
let target_family_id = version_of
.get(&OutputKey(i, 0))
.map(|&(family, _, _)| family)
.or_else(|| {
source_family
.get(&TransitionTargetKey::Authored(
bound[i]["colorTarget"].producer,
))
.copied()
});
let target_descriptor = target_family_id
.and_then(|family| known_family_descriptor(family, &families, &default_roots));
let bloom = if contracts[i].fullscreen_policy == Some(FullscreenPolicy::BloomComposite) {
Some(sampled_descriptor(
bound[i]["bloom"].producer,
&version_of,
&resolved,
&families,
&default_roots,
)?)
} else {
None
};
let bloom_descriptor = match &bloom {
Some(SampledDescriptor::Known(descriptor)) => Some(*descriptor),
_ => None,
};
let source_ok = source_descriptor.is_none_or(|descriptor| {
descriptor.format == TextureFormat::Rgba16Float && is_single_view_d2(descriptor)
});
let target_ok = target_descriptor.is_none_or(|descriptor| {
is_single_view_d2(descriptor)
&& match contracts[i].fullscreen_policy {
Some(FullscreenPolicy::Copy) => {
descriptor.format != TextureFormat::Depth32Float
}
Some(FullscreenPolicy::BloomExtract)
| Some(FullscreenPolicy::HdrSameExtent)
| Some(FullscreenPolicy::BloomComposite) => {
descriptor.format == TextureFormat::Rgba16Float
}
_ => false,
}
});
let bloom_ok = bloom_descriptor.is_none_or(|descriptor| {
descriptor.format == TextureFormat::Rgba16Float && is_single_view_d2(descriptor)
});
let extent_ok = match contracts[i].fullscreen_policy {
Some(FullscreenPolicy::Copy)
| Some(FullscreenPolicy::HdrSameExtent)
| Some(FullscreenPolicy::BloomComposite) => {
!matches!((source_descriptor, target_descriptor), (Some(source), Some(target)) if source.extent != target.extent)
}
Some(FullscreenPolicy::BloomExtract) => true,
_ => false,
};
if !source_ok || !target_ok || !bloom_ok || !extent_ok {
return Err(error(
"GRAPH_ILLEGAL_ACCESS",
"fullscreen textures are incompatible",
format!("nodes[{i}].inputs"),
));
}
if matches!(source, SampledDescriptor::Unproduced) {
return Err(error(
"GRAPH_UNINITIALIZED_RESOURCE",
"copy source is not produced",
format!("nodes[{i}].inputs.source"),
));
};
let Some(&(target_family_id, _, _)) = version_of.get(&OutputKey(i, 0)) else {
continue;
};
let source_descriptor = match &families[source_family_id as usize].source {
TextureFamilySource::AuthoredTexture { descriptor, .. } => descriptor,
};
let source_ok = source_descriptor.format == TextureFormat::Rgba16Float
&& is_single_view_d2(source_descriptor);
let target_descriptor = match &families[target_family_id as usize].source {
TextureFamilySource::AuthoredTexture { descriptor, .. } => Some(descriptor),
};
let authored_target_ok = target_descriptor.is_some_and(|descriptor| {
descriptor.format == TextureFormat::Rgba16Float && is_single_view_d2(descriptor)
});
let bloom_input_ok = if contracts[i].fullscreen_policy
== Some(FullscreenPolicy::BloomComposite)
{
let bloom_key = bound[i]["bloom"].producer;
let Some(&(bloom_family_id, _, _)) = version_of.get(&bloom_key) else {
return Err(error(
"GRAPH_UNINITIALIZED_RESOURCE",
"bloom source is not produced",
format!("nodes[{i}].inputs.bloom"),
));
};
match &families[bloom_family_id as usize].source {
TextureFamilySource::AuthoredTexture { descriptor, .. } => {
descriptor.format == TextureFormat::Rgba16Float && is_single_view_d2(descriptor)
}
}
} else {
true
};
let source_is_full_surface = matches!(&source_descriptor.extent, NormalizedTextureExtent::SurfaceRelative { width, height, depth_or_array_layers: 1 } if *width == Ratio { numerator:1, denominator:1 } && *height == Ratio { numerator:1, denominator:1 });
let target_matches_source = target_descriptor
.is_some_and(|descriptor| descriptor.extent == source_descriptor.extent);
let descriptor_ok = match contracts[i].fullscreen_policy {
Some(FullscreenPolicy::Copy) => {
target_descriptor.is_none() && source_is_full_surface
|| target_descriptor.is_some_and(|descriptor| {
descriptor.format != TextureFormat::Depth32Float
&& is_single_view_d2(descriptor)
&& descriptor.extent == source_descriptor.extent
})
}
Some(FullscreenPolicy::BloomExtract) => authored_target_ok,
Some(FullscreenPolicy::HdrSameExtent) => authored_target_ok && target_matches_source,
Some(FullscreenPolicy::BloomComposite) => {
authored_target_ok && target_matches_source && bloom_input_ok
}
_ => false,
};
if !source_ok || !descriptor_ok {
}
if matches!(bloom, Some(SampledDescriptor::Unproduced)) {
return Err(error(
"GRAPH_ILLEGAL_ACCESS",
"fullscreen textures are incompatible",
format!("nodes[{i}].inputs"),
"GRAPH_UNINITIALIZED_RESOURCE",
"bloom source is not produced",
format!("nodes[{i}].inputs.bloom"),
));
}
}
@@ -1436,8 +1655,9 @@ pub fn compile(graph: Graph) -> Result<CompiledGraph, GraphError> {
}
continue;
};
let TextureFamilySource::AuthoredTexture { descriptor, .. } =
&families[family as usize].source;
let Some(descriptor) = known_family_descriptor(family, &families, &default_roots) else {
continue;
};
let NormalizedParameters::FrameOut { dynamic_range, .. } = &params[i] else {
unreachable!()
};
@@ -1569,6 +1789,9 @@ pub fn compile(graph: Graph) -> Result<CompiledGraph, GraphError> {
if transitions
.iter()
.any(|transition| matches!(resolved[&transition.output], ResolvedTransition::Cyclic))
|| default_roots
.iter()
.any(|draft| matches!(draft.descriptor, DraftDescriptor::Deferred))
{
return Err(error(
"GRAPH_RESOURCE_VERSION_INVALID",
@@ -1577,6 +1800,64 @@ pub fn compile(graph: Graph) -> Result<CompiledGraph, GraphError> {
));
}
for draft in &default_roots {
let DraftDescriptor::Known(descriptor) = &draft.descriptor else {
unreachable!("deferred drafts rejected above")
};
families.push(TextureFamily {
id: draft.family,
key: TextureFamilyKey {
source_node: draft.owner_node as u32,
source_socket: draft.input_ordinal,
},
source: TextureFamilySource::CompilerDefaultInput {
resource: draft.resource,
owner_node_index: draft.owner_node as u32,
input_ordinal: draft.input_ordinal,
role: draft.role,
descriptor: descriptor.clone(),
},
lifetime: Lifetime {
first_use: 0,
last_use: 0,
},
versions: vec![],
usage: vec![],
allocation: None,
aliasable: false,
});
}
for transition in &transitions {
if let Some(&(family, version, target)) = version_of.get(&transition.output) {
families[family as usize].versions.push(TextureVersion {
version,
resource: output_ids[&transition.output],
target,
initialized: true,
stored: true,
lifetime: Lifetime {
first_use: 0,
last_use: 0,
},
});
}
}
for family in &mut families {
family.versions.sort_by_key(|version| version.version);
if family
.versions
.iter()
.enumerate()
.any(|(index, version)| version.version != index as u32)
{
return Err(error(
"GRAPH_RESOURCE_VERSION_INVALID",
"texture versions must form a dense linear chain",
"resources",
));
}
}
let mut resources = Vec::new();
for (i, o, out) in resource_meta {
let key = OutputKey(i, o);
@@ -1589,7 +1870,7 @@ pub fn compile(graph: Graph) -> Result<CompiledGraph, GraphError> {
} = &params[i]
{
ResourcePlan::TextureSource {
family: source_family[&key],
family: source_family[&TransitionTargetKey::Authored(key)],
residency: *residency,
descriptor: descriptor.clone(),
}
@@ -1625,10 +1906,10 @@ pub fn compile(graph: Graph) -> Result<CompiledGraph, GraphError> {
};
resources.push(CompiledResource {
original_node_index: i as u32,
output_ordinal: o,
origin: NodeOutputRef {
origin: ResourceOrigin::AuthoredOutput {
node: graph.nodes[i].id.clone(),
socket: out.name.into(),
output_ordinal: o,
},
semantic_type: out.semantic_type,
producer_execution: None,
@@ -1637,6 +1918,28 @@ pub fn compile(graph: Graph) -> Result<CompiledGraph, GraphError> {
});
let _ = id;
}
for draft in &default_roots {
let DraftDescriptor::Known(descriptor) = &draft.descriptor else {
unreachable!("deferred drafts rejected above")
};
resources.push(CompiledResource {
original_node_index: draft.owner_node as u32,
origin: ResourceOrigin::CompilerDefaultInput {
owner_node_index: draft.owner_node as u32,
input_ordinal: draft.input_ordinal,
socket: draft.socket.into(),
role: draft.role,
},
semantic_type: SemanticType::Texture,
producer_execution: None,
lifetime: None,
plan: ResourcePlan::TextureSource {
family: draft.family,
residency: TextureResidency::Transient,
descriptor: descriptor.clone(),
},
});
}
let mut executions = Vec::new();
for &i in &order {
if matches!(
@@ -1647,14 +1950,26 @@ pub fn compile(graph: Graph) -> Result<CompiledGraph, GraphError> {
}
let input_resource = |s: &str| output_ids[&bound[i][s].producer];
let mut inputs = Vec::new();
for s in contracts[i].inputs {
for (input_ordinal, s) in contracts[i].inputs.iter().enumerate() {
if s.role != InputRole::Expression {
let Some(b) = bound[i].get(s.name) else {
let resource = if let Some(b) = bound[i].get(s.name) {
output_ids[&b.producer]
} else if s.default_policy == InputDefaultPolicy::CompilerTexture {
let key = TransitionTargetKey::CompilerDefaultInput {
owner_node: i,
input_ordinal: input_ordinal as u16,
};
default_roots
.iter()
.find(|root| root.key == key)
.expect("default policy materialized a root")
.resource
} else {
continue;
};
inputs.push(CompiledSocketInput {
socket: s.name.into(),
resource: output_ids[&b.producer],
resource,
});
}
}
@@ -2095,13 +2410,13 @@ pub fn compile(graph: Graph) -> Result<CompiledGraph, GraphError> {
last_use: last,
};
f.usage = texture_usage(f, &executions);
f.aliasable = matches!(
f.source,
TextureFamilySource::AuthoredTexture {
residency: TextureResidency::Transient,
..
let transient = match f.source {
TextureFamilySource::AuthoredTexture { residency, .. } => {
residency == TextureResidency::Transient
}
) && f.versions.iter().all(|v| v.initialized);
TextureFamilySource::CompilerDefaultInput { .. } => true,
};
f.aliasable = transient && f.versions.iter().all(|v| v.initialized);
}
let (classes, transient) = allocate(&mut families, &mut resources);
if resources.len() > 1024 {
@@ -2121,7 +2436,7 @@ pub fn compile(graph: Graph) -> Result<CompiledGraph, GraphError> {
texture_families: families,
allocation_classes: classes,
culled_node_count: (graph.nodes.len() - live.len()) as u32,
culled_resource_count: (all_outputs - output_ids.len()) as u32,
culled_resource_count: (all_outputs - authored_materialized_output_count) as u32,
transient_slot_count: transient,
instance_traversal,
})
@@ -2139,6 +2454,12 @@ fn extent_layers(e: &NormalizedTextureExtent) -> u32 {
} => *depth_or_array_layers,
}
}
pub(super) fn family_descriptor(family: &TextureFamily) -> &NormalizedTextureDescriptor {
match &family.source {
TextureFamilySource::AuthoredTexture { descriptor, .. }
| TextureFamilySource::CompilerDefaultInput { descriptor, .. } => descriptor,
}
}
pub(super) fn is_single_view_d2(descriptor: &NormalizedTextureDescriptor) -> bool {
descriptor.dimension == TextureDimension::D2
&& descriptor.sample_count == 1
@@ -2195,7 +2516,7 @@ fn allocate(
) -> (Vec<AllocationClass>, u32) {
let mut grouped: BTreeMap<TextureCompatibilityKey, Vec<usize>> = BTreeMap::new();
for (i, f) in families.iter().enumerate() {
let TextureFamilySource::AuthoredTexture { descriptor, .. } = &f.source;
let descriptor = family_descriptor(f);
grouped
.entry(TextureCompatibilityKey {
dimension: descriptor.dimension,
renderer/src/render_graph/contracts.rs
+21 -3
View File
@@ -44,6 +44,13 @@ pub enum InputCardinality {
OptionalOne,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "snake_case")]
pub enum InputDefaultPolicy {
None,
ParameterLiteral,
CompilerTexture,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
#[serde(tag = "kind", content = "types", rename_all = "snake_case")]
pub enum TypeConstraint {
Exact(SemanticType),
@@ -67,6 +74,7 @@ pub struct InputSocketContract {
pub name: &'static str,
pub accepted: TypeConstraint,
pub cardinality: InputCardinality,
pub default_policy: InputDefaultPolicy,
pub role: InputRole,
}
#[derive(Clone, Copy, Debug, serde::Serialize)]
@@ -97,10 +105,20 @@ const fn i(
cardinality: InputCardinality,
role: InputRole,
) -> InputSocketContract {
let default_policy = match cardinality {
InputCardinality::RequiredOne => InputDefaultPolicy::None,
InputCardinality::OptionalOne => match role {
InputRole::ColorTarget { .. } | InputRole::DepthTarget => {
InputDefaultPolicy::CompilerTexture
}
_ => InputDefaultPolicy::ParameterLiteral,
},
};
InputSocketContract {
name,
accepted: TypeConstraint::Exact(ty),
cardinality,
default_policy,
role,
}
}
@@ -124,10 +142,10 @@ const PIPE_I: &[InputSocketContract] = &[
i(
"colorTarget",
Texture,
R,
O,
InputRole::ColorTarget { location: 0 },
),
i("depthTarget", Texture, R, InputRole::DepthTarget),
i("depthTarget", Texture, O, InputRole::DepthTarget),
];
const PIPE_O: &[OutputSocketContract] = &[o("color", Texture), o("depth", Texture)];
const CULL_I: &[InputSocketContract] = &[
@@ -181,7 +199,7 @@ pub static CONTRACTS: &[Contract] = &[
c!("mesh", 2, Source, NONE_I, MESH_O, false, None),
c!("texture", 1, Source, NONE_I, TEXTURE_O, false, None),
c!("frustum_cull", 2, Expression, CULL_I, CULL_O, false, None),
c!("pipeline", 2, Render, PIPE_I, PIPE_O, false, None),
c!("pipeline", 3, Render, PIPE_I, PIPE_O, false, None),
ex!("and", ins!("left":Bool,"right":Bool), outs!("value":Bool)),
ex!("or", ins!("left":Bool,"right":Bool), outs!("value":Bool)),
ex!("not", ins!("operand":Bool), outs!("value":Bool)),
renderer/src/render_graph/plan.rs
+32 -3
View File
@@ -24,14 +24,36 @@ pub struct CompiledGraph {
#[serde(rename_all = "camelCase")]
pub struct CompiledResource {
pub original_node_index: u32,
pub output_ordinal: u16,
pub origin: NodeOutputRef,
pub origin: ResourceOrigin,
pub semantic_type: SemanticType,
pub producer_execution: Option<u32>,
pub lifetime: Option<Lifetime>,
pub plan: ResourcePlan,
}
#[derive(Clone, Debug, Serialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum ResourceOrigin {
AuthoredOutput {
node: String,
socket: String,
output_ordinal: u16,
},
CompilerDefaultInput {
owner_node_index: u32,
input_ordinal: u16,
socket: String,
role: CompilerTextureRole,
},
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum CompilerTextureRole {
ColorTarget,
DepthTarget,
}
#[derive(Clone, Debug, Serialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum ResourcePlan {
@@ -331,7 +353,7 @@ pub struct Lifetime {
pub last_use: u32,
}
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize)]
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TextureFamilyKey {
pub source_node: u32,
@@ -346,6 +368,13 @@ pub enum TextureFamilySource {
residency: TextureResidency,
descriptor: NormalizedTextureDescriptor,
},
CompilerDefaultInput {
resource: u32,
owner_node_index: u32,
input_ordinal: u16,
role: CompilerTextureRole,
descriptor: NormalizedTextureDescriptor,
},
}
#[derive(Clone, Debug, Serialize)]
renderer/src/render_graph/runtime.rs
+248 -19
View File
@@ -395,7 +395,8 @@ fn texture_descriptor<'a>(
_ => return None,
};
match &graph.texture_families.get(family as usize)?.source {
TextureFamilySource::AuthoredTexture { descriptor, .. } => Some(descriptor),
TextureFamilySource::AuthoredTexture { descriptor, .. }
| TextureFamilySource::CompilerDefaultInput { descriptor, .. } => Some(descriptor),
}
}
@@ -682,6 +683,19 @@ fn validate_fullscreen_execution(
}
fn validate_canonical_plan(graph: &CompiledGraph) -> Result<(), GraphError> {
fn texture_family_for_resource<'a>(
graph: &'a CompiledGraph,
resource: u32,
) -> Option<&'a TextureFamily> {
let resource = graph.resources.get(resource as usize)?;
let family = match resource.plan {
ResourcePlan::TextureSource { family, .. } | ResourcePlan::Texture { family, .. } => {
family
}
_ => return None,
};
graph.texture_families.get(family as usize)
}
for (i, resource) in graph.resources.iter().enumerate() {
if resource.semantic_type.is_virtual() {
return Err(invalid(
@@ -795,28 +809,221 @@ fn validate_canonical_plan(graph: &CompiledGraph) -> Result<(), GraphError> {
}
}
let mut family_keys = HashSet::new();
let mut source_claims = vec![0u8; graph.resources.len()];
for (fi, family) in graph.texture_families.iter().enumerate() {
let TextureFamilySource::AuthoredTexture {
resource: source,
residency,
descriptor,
} = &family.source;
let source_resource = graph.resources.get(*source as usize).ok_or_else(|| {
if family.id as usize != fi || !family_keys.insert(family.key.clone()) {
return Err(invalid(
"texture family id/key is not unique and canonical",
format!("textureFamilies[{fi}]"),
));
}
let (source, residency, descriptor) = match &family.source {
TextureFamilySource::AuthoredTexture {
resource,
residency,
descriptor,
} => (*resource, *residency, descriptor),
TextureFamilySource::CompilerDefaultInput {
resource,
descriptor,
..
} => (*resource, TextureResidency::Transient, descriptor),
};
let source_resource = graph.resources.get(source as usize).ok_or_else(|| {
invalid(
"texture source resource is out of bounds",
format!("textureFamilies[{fi}].source.resource"),
)
})?;
source_claims[source as usize] = source_claims[source as usize].saturating_add(1);
if source_resource.semantic_type != SemanticType::Texture
|| source_resource.producer_execution.is_some()
|| !matches!(&source_resource.plan, ResourcePlan::TextureSource { family: f, residency: r, descriptor: d }
if *f == family.id && r == residency && d == descriptor)
if *f == family.id && *r == residency && d == descriptor)
{
return Err(invalid(
"texture family source is not canonical",
format!("textureFamilies[{fi}].source"),
));
}
let origin_ok = match (&family.source, &source_resource.origin) {
(
TextureFamilySource::AuthoredTexture { resource, .. },
ResourceOrigin::AuthoredOutput {
node: _,
socket,
output_ordinal,
},
) => {
family.key.source_node == source_resource.original_node_index
&& family.key.source_socket == 0
&& *output_ordinal == 0
&& *socket == "texture"
&& *resource == source
&& source_resource.producer_execution.is_none()
}
(
TextureFamilySource::CompilerDefaultInput {
owner_node_index,
input_ordinal,
role,
..
},
ResourceOrigin::CompilerDefaultInput {
owner_node_index: owner,
input_ordinal: input,
socket,
role: origin_role,
},
) => {
let owner_executions: Vec<_> = graph
.executions
.iter()
.filter(|execution| execution.original_node_index == *owner_node_index)
.collect();
let owner_input_ok = owner_executions
.as_slice()
.first()
.is_some_and(|execution| {
execution
.inputs
.iter()
.filter(|input| input.socket == *socket && input.resource == source)
.count()
== 1
})
&& owner_executions[0].executor.key == "pipeline"
&& owner_executions[0].executor.version == 3
&& graph
.executions
.iter()
.flat_map(|execution| &execution.inputs)
.filter(|input| input.resource == source)
.count()
== 1
&& contract("pipeline")
.and_then(|contract| contract.inputs.get(*input_ordinal as usize))
.is_some_and(|input| {
input.name == *socket
&& matches!(
(input.role, role),
(
InputRole::ColorTarget { location: 0 },
CompilerTextureRole::ColorTarget
) | (InputRole::DepthTarget, CompilerTextureRole::DepthTarget)
)
});
owner == owner_node_index
&& owner_executions.len() == 1
&& input == input_ordinal
&& origin_role == role
&& owner_input_ok
&& socket
== if *role == CompilerTextureRole::ColorTarget {
"colorTarget"
} else {
"depthTarget"
}
}
_ => false,
};
if !origin_ok {
return Err(invalid(
"texture source origin is not canonical",
format!("resources[{source}].origin"),
));
}
if let TextureFamilySource::CompilerDefaultInput {
owner_node_index,
input_ordinal,
role,
descriptor,
..
} = &family.source
{
let fixed = descriptor.dimension == TextureDimension::D2
&& descriptor.format
== if *role == CompilerTextureRole::ColorTarget {
TextureFormat::Rgba16Float
} else {
TextureFormat::Depth32Float
}
&& descriptor.mip_level_count == 1
&& descriptor.sample_count == 1
&& descriptor.view_formats.is_empty()
&& matches!(
descriptor.extent,
NormalizedTextureExtent::Absolute {
depth_or_array_layers: 1,
..
} | NormalizedTextureExtent::SurfaceRelative {
depth_or_array_layers: 1,
..
}
)
&& family.key.source_node == *owner_node_index
&& family.key.source_socket == *input_ordinal
&& source_resource.original_node_index == *owner_node_index;
if !fixed {
return Err(invalid(
"compiler default descriptor is not canonical",
format!("textureFamilies[{fi}].source.descriptor"),
));
}
let owner = graph
.executions
.iter()
.find(|execution| execution.original_node_index == *owner_node_index)
.expect("origin validation found owner");
let opposite_socket = if *role == CompilerTextureRole::ColorTarget {
"depthTarget"
} else {
"colorTarget"
};
let opposite_resource = owner
.inputs
.iter()
.find(|input| input.socket == opposite_socket)
.map(|input| input.resource)
.ok_or_else(|| {
invalid(
"compiler default opposite input is missing",
format!("executions[{owner_node_index}].inputs"),
)
})?;
let opposite_family = texture_family_for_resource(graph, opposite_resource)
.ok_or_else(|| {
invalid(
"compiler default opposite input is invalid",
format!("executions[{owner_node_index}].inputs"),
)
})?;
let both_defaults = matches!(&opposite_family.source, TextureFamilySource::CompilerDefaultInput { owner_node_index: opposite_owner, .. } if opposite_owner == owner_node_index);
let expected_extent = if both_defaults {
NormalizedTextureExtent::SurfaceRelative {
width: Ratio {
numerator: 1,
denominator: 1,
},
height: Ratio {
numerator: 1,
denominator: 1,
},
depth_or_array_layers: 1,
}
} else {
super::compiler::family_descriptor(opposite_family)
.extent
.clone()
};
if descriptor.extent != expected_extent {
return Err(invalid(
"compiler default extent is not canonical",
format!("textureFamilies[{fi}].source.descriptor.extent"),
));
}
}
if family.versions.is_empty() {
return Err(invalid(
"texture family has no versions",
@@ -828,7 +1035,7 @@ fn validate_canonical_plan(graph: &CompiledGraph) -> Result<(), GraphError> {
let mut all_initialized = true;
for (vi, version) in family.versions.iter().enumerate() {
let expected_target = if vi == 0 {
*source
source
} else {
family.versions[vi - 1].resource
};
@@ -870,7 +1077,7 @@ fn validate_canonical_plan(graph: &CompiledGraph) -> Result<(), GraphError> {
format!("textureFamilies[{fi}].lifetime"),
));
}
let expected_aliasable = *residency == TextureResidency::Transient && all_initialized;
let expected_aliasable = residency == TextureResidency::Transient && all_initialized;
if family.aliasable != expected_aliasable {
return Err(invalid(
"texture family aliasability is not canonical",
@@ -878,6 +1085,15 @@ fn validate_canonical_plan(graph: &CompiledGraph) -> Result<(), GraphError> {
));
}
}
for (ri, resource) in graph.resources.iter().enumerate() {
let is_source = matches!(resource.plan, ResourcePlan::TextureSource { .. });
if is_source != (source_claims[ri] == 1) {
return Err(invalid(
"texture source must be claimed by exactly one family",
format!("resources[{ri}].plan"),
));
}
}
Ok(())
}
@@ -1590,7 +1806,7 @@ pub fn prepare_runtime_plan(
format!("resources[{color}].plan.family"),
)
})?;
let TextureFamilySource::AuthoredTexture { descriptor, .. } = &family.source;
let descriptor = super::compiler::family_descriptor(family);
if !super::compiler::frame_out_source_compatible(descriptor, dynamic_range) {
return Err(invalid(
"frame_out texture descriptor is incompatible",
@@ -1648,6 +1864,14 @@ pub fn prepare_runtime_plan(
));
}
}
TextureFamilySource::CompilerDefaultInput { descriptor, .. } => {
if !super::compiler::is_single_view_d2(descriptor) || family.allocation.is_none() {
return Err(invalid(
"compiler default family is not canonical",
format!("textureFamilies[{fi}]"),
));
}
}
}
for (vi, version) in family.versions.iter().enumerate() {
if version.version as usize != vi {
@@ -1755,24 +1979,29 @@ pub fn prepare_runtime_plan(
format!("allocationClasses[{ci}].slots[{si}].occupants"),
));
}
let TextureFamilySource::AuthoredTexture {
descriptor,
residency,
..
} = &family.source;
let (descriptor, residency) = match &family.source {
TextureFamilySource::AuthoredTexture {
descriptor,
residency,
..
} => (descriptor, *residency),
TextureFamilySource::CompilerDefaultInput { descriptor, .. } => {
(descriptor, TextureResidency::Transient)
}
};
expected_usage.extend(family.usage.iter().copied());
let kind_valid = match slot.kind {
AllocationKind::AliasedTransient => {
*residency == TextureResidency::Transient && family.aliasable
residency == TextureResidency::Transient && family.aliasable
}
AllocationKind::DedicatedTransient => {
slot.occupants.len() == 1
&& *residency == TextureResidency::Transient
&& residency == TextureResidency::Transient
&& !family.aliasable
}
AllocationKind::Persistent => {
slot.occupants.len() == 1
&& *residency == TextureResidency::Persistent
&& residency == TextureResidency::Persistent
&& !family.aliasable
}
};
renderer/src/render_graph/tests.rs
+549 -2
View File
@@ -21,6 +21,13 @@ fn texture(id: &str, format: &str) -> Value {
})
}
fn set_extent_ratio(texture: &mut Value, numerator: u32, denominator: u32) {
texture["parameters"]["texture"]["extent"]["width"] =
json!({"numerator":numerator,"denominator":denominator});
texture["parameters"]["texture"]["extent"]["height"] =
json!({"numerator":numerator,"denominator":denominator});
}
fn node(id: &str, key: &str, version: u32, parameters: Value, inputs: Value) -> Value {
json!({ "id": id, "state": "enabled", "executor": { "key": key, "version": version },
"parameters": parameters, "inputs": inputs })
@@ -38,7 +45,7 @@ pub(crate) fn full_cull_graph() -> Value {
node("visible", "not", 1, json!({"operandDefault":false}), json!({"operand":input("cull","isFrustumCulled")})),
node("class", "and", 1, json!({"leftDefault":true,"rightDefault":true}),
json!({"left":input("bits","bit0"),"right":input("visible","value")})),
node("pipeline", "pipeline", 2,
node("pipeline", "pipeline", 3,
json!({"pipeline":"gltf_standard","depthCompare":"less_equal","depthWriteEnabled":true,"clearDepth":1.0,"clearColor":[0,0,0,1],"predicateDefault":true}),
json!({"mesh":input("mesh","mesh"),"predicate":input("class","value"),"colorTarget":input("color","texture"),"depthTarget":input("depth","texture")})),
node("frame", "frame_out", 3,
@@ -51,7 +58,7 @@ pub(crate) fn full_cull_graph() -> Value {
#[test]
fn catalog_exposes_final_mesh_pipeline_and_generic_expression_contracts() {
assert_eq!(contract("mesh").unwrap().version, 2);
assert_eq!(contract("pipeline").unwrap().version, 2);
assert_eq!(contract("pipeline").unwrap().version, 3);
assert_eq!(
contract("mesh")
.unwrap()
@@ -145,3 +152,543 @@ fn expression_provenance_rejects_cross_mesh_values() {
let error = compile_value(graph).unwrap_err();
assert_eq!(error.code, "GRAPH_SOCKET_TYPE_MISMATCH");
}
fn implicit_pipeline_graph() -> Value {
json!({ "schemaVersion": 2, "graphId": "implicit", "revision": 1, "nodes": [
node("mesh", "mesh", 2, json!({}), json!({})),
node("first", "pipeline", 3,
json!({"pipeline":"ground_plane","depthCompare":"less_equal","depthWriteEnabled":true,"clearDepth":1.0,"clearColor":[0,0,0,1],"predicateDefault":true}),
json!({"mesh":input("mesh","mesh")})),
node("second", "pipeline", 3,
json!({"pipeline":"gltf_standard","depthCompare":"less_equal","depthWriteEnabled":true,"clearDepth":1.0,"clearColor":[0,0,0,1],"predicateDefault":true}),
json!({"mesh":input("mesh","mesh"),"colorTarget":input("first","color"),"depthTarget":input("first","depth")})),
node("frame", "frame_out", 3,
json!({"surfaceFormat":"preferred","hdrEnabled":true,"toneMapper":"aces","exposureStops":0,"outputTransfer":"srgb","scaleMode":"stretch","filter":"linear","backgroundColor":[0,0,0,1]}),
json!({"color":input("second","color")}))
]})
}
#[test]
fn contract_v3_declares_strict_default_policies() {
let pipeline = contract("pipeline").unwrap();
assert_eq!(pipeline.version, 3);
assert_eq!(pipeline.inputs[0].default_policy, InputDefaultPolicy::None);
assert_eq!(
pipeline.inputs[1].default_policy,
InputDefaultPolicy::ParameterLiteral
);
assert_eq!(
pipeline.inputs[2].default_policy,
InputDefaultPolicy::CompilerTexture
);
assert_eq!(
pipeline.inputs[3].default_policy,
InputDefaultPolicy::CompilerTexture
);
assert!(CONTRACTS
.iter()
.flat_map(|c| c.inputs)
.all(|input| matches!(
(input.cardinality, input.default_policy),
(InputCardinality::RequiredOne, InputDefaultPolicy::None)
| (
InputCardinality::OptionalOne,
InputDefaultPolicy::ParameterLiteral
)
| (
InputCardinality::OptionalOne,
InputDefaultPolicy::CompilerTexture
)
)));
}
#[test]
fn disconnected_targets_have_tagged_roots_and_clear_version_zero() {
let compiled = compile_value(implicit_pipeline_graph()).unwrap();
let roots: Vec<_> = compiled
.resources
.iter()
.filter(|r| matches!(r.origin, ResourceOrigin::CompilerDefaultInput { .. }))
.collect();
assert_eq!(roots.len(), 2);
assert_eq!(compiled.culled_resource_count, 0);
assert!(compiled
.texture_families
.iter()
.take(2)
.all(|f| f.aliasable));
let first = compiled
.executions
.iter()
.find(|e| e.id == "first")
.unwrap();
let ExecutionKind::Render {
color_attachments,
depth_stencil: Some(depth),
} = &first.kind
else {
panic!()
};
assert!(matches!(
color_attachments[0].load,
NormalizedColorLoad::Clear { .. }
));
assert!(matches!(depth.load, NormalizedDepthLoad::Clear { .. }));
}
#[test]
fn implicit_chain_is_deterministic_and_loads_successors() {
let a = compile_value(implicit_pipeline_graph()).unwrap();
let b = compile_value(implicit_pipeline_graph()).unwrap();
assert_eq!(
serde_json::to_value(&a).unwrap(),
serde_json::to_value(&b).unwrap()
);
let second = a.executions.iter().find(|e| e.id == "second").unwrap();
let ExecutionKind::Render {
color_attachments,
depth_stencil: Some(depth),
} = &second.kind
else {
panic!()
};
assert_eq!(color_attachments[0].load, NormalizedColorLoad::Load);
assert_eq!(depth.load, NormalizedDepthLoad::Load);
}
#[test]
fn one_missing_attachment_copies_authored_opposite_extent() {
for missing in ["colorTarget", "depthTarget"] {
let mut graph = full_cull_graph();
graph["nodes"][8]["inputs"]
.as_object_mut()
.unwrap()
.remove(missing);
let compiled = compile_value(graph).unwrap();
let default = compiled
.texture_families
.iter()
.find(|f| matches!(f.source, TextureFamilySource::CompilerDefaultInput { .. }))
.unwrap();
let explicit = compiled
.texture_families
.iter()
.find(|f| {
matches!(f.source, TextureFamilySource::AuthoredTexture { .. })
&& f.id != default.id
})
.unwrap();
assert_eq!(
super::compiler::family_descriptor(default).extent,
super::compiler::family_descriptor(explicit).extent
);
}
}
#[test]
fn default_extent_follows_half_surface_and_prior_default_families() {
let mut half = full_cull_graph();
set_extent_ratio(&mut half["nodes"][0], 1, 2);
half["nodes"][8]["inputs"]
.as_object_mut()
.unwrap()
.remove("depthTarget");
let compiled = compile_value(half).unwrap();
let default = compiled
.texture_families
.iter()
.find(|family| {
matches!(
family.source,
TextureFamilySource::CompilerDefaultInput { .. }
)
})
.unwrap();
assert_eq!(
super::compiler::family_descriptor(default).extent,
NormalizedTextureExtent::SurfaceRelative {
width: Ratio {
numerator: 1,
denominator: 2
},
height: Ratio {
numerator: 1,
denominator: 2
},
depth_or_array_layers: 1
}
);
let compiled = compile_value(implicit_pipeline_graph()).unwrap();
let defaults: Vec<_> = compiled
.texture_families
.iter()
.filter(|family| {
matches!(
family.source,
TextureFamilySource::CompilerDefaultInput { .. }
)
})
.collect();
assert_eq!(defaults.len(), 2);
assert_eq!(
super::compiler::family_descriptor(defaults[0]).extent,
super::compiler::family_descriptor(defaults[1]).extent
);
}
#[test]
fn explicit_attachment_diagnostics_are_socket_specific_then_mutual() {
let mut color = full_cull_graph();
color["nodes"][0]["parameters"]["texture"]["format"] = json!("depth32_float");
let error = compile_value(color).unwrap_err();
assert_eq!(error.details["path"], "nodes[8].inputs.colorTarget");
let mut depth = full_cull_graph();
depth["nodes"][1]["parameters"]["texture"]["format"] = json!("rgba16_float");
let error = compile_value(depth).unwrap_err();
assert_eq!(error.details["path"], "nodes[8].inputs.depthTarget");
let mut mismatch = full_cull_graph();
set_extent_ratio(&mut mismatch["nodes"][1], 1, 2);
let error = compile_value(mismatch).unwrap_err();
assert_eq!(error.details["path"], "nodes[8].inputs");
}
#[test]
fn descriptor_dependency_cycle_keeps_graph_cycle_priority() {
let mut graph = implicit_pipeline_graph();
graph["nodes"][1]["inputs"]["depthTarget"] = input("second", "depth");
graph["nodes"][2]["inputs"]
.as_object_mut()
.unwrap()
.remove("depthTarget");
assert_eq!(compile_value(graph).unwrap_err().code, "GRAPH_CYCLE");
}
#[test]
fn known_attachment_error_precedes_cycle() {
let mut graph = full_cull_graph();
graph["nodes"][0]["parameters"]["texture"]["format"] = json!("depth32_float");
graph["nodes"][8]["inputs"]["depthTarget"] = input("pipeline", "depth");
let error = compile_value(graph).unwrap_err();
assert_eq!(error.code, "GRAPH_ILLEGAL_ACCESS");
assert_eq!(error.details["path"], "nodes[8].inputs.colorTarget");
}
fn self_targeting_copy(source_format: &str) -> Value {
let mut graph = full_cull_graph();
graph["nodes"][0]["parameters"]["texture"]["format"] = json!(source_format);
graph["nodes"].as_array_mut().unwrap().insert(
9,
node(
"copy",
"fullscreen_copy",
1,
json!({}),
json!({
"source": input("pipeline", "color"),
"colorTarget": input("copy", "color")
}),
),
);
graph["nodes"][10]["inputs"]["color"] = input("copy", "color");
graph
}
#[test]
fn known_invalid_fullscreen_source_precedes_target_cycle() {
let error = compile_value(self_targeting_copy("rgba8_unorm")).unwrap_err();
assert_eq!(error.code, "GRAPH_ILLEGAL_ACCESS");
assert_eq!(error.details["path"], "nodes[9].inputs");
assert_eq!(
compile_value(self_targeting_copy("rgba16_float"))
.unwrap_err()
.code,
"GRAPH_CYCLE"
);
}
#[test]
fn known_invalid_fullscreen_target_precedes_source_cycle() {
let mut graph = implicit_pipeline_graph();
graph["nodes"][1]["inputs"]["depthTarget"] = input("second", "depth");
graph["nodes"][2]["inputs"]
.as_object_mut()
.unwrap()
.remove("depthTarget");
graph["nodes"]
.as_array_mut()
.unwrap()
.insert(3, texture("saturation_target", "rgba8_unorm"));
graph["nodes"].as_array_mut().unwrap().insert(
4,
node(
"saturation",
"saturation",
1,
json!({"saturation":1,"factor":1}),
json!({
"source": input("second", "color"),
"colorTarget": input("saturation_target", "texture")
}),
),
);
graph["nodes"][5]["parameters"]["hdrEnabled"] = json!(false);
graph["nodes"][5]["inputs"]["color"] = input("saturation", "color");
let error = compile_value(graph).unwrap_err();
assert_eq!(error.code, "GRAPH_ILLEGAL_ACCESS");
assert_eq!(error.details["path"], "nodes[4].inputs");
}
fn self_targeting_composite(bloom_format: &str) -> Value {
let mut graph = full_cull_graph();
graph["nodes"]
.as_array_mut()
.unwrap()
.insert(9, texture("bloom_target", bloom_format));
graph["nodes"].as_array_mut().unwrap().insert(
10,
node(
"bloom_copy",
"fullscreen_copy",
1,
json!({}),
json!({
"source": input("pipeline", "color"),
"colorTarget": input("bloom_target", "texture")
}),
),
);
graph["nodes"].as_array_mut().unwrap().insert(
11,
node(
"composite",
"bloom_composite",
1,
json!({"intensity":1}),
json!({
"source": input("pipeline", "color"),
"bloom": input("bloom_copy", "color"),
"colorTarget": input("composite", "color")
}),
),
);
graph["nodes"][12]["inputs"]["color"] = input("composite", "color");
graph
}
#[test]
fn known_invalid_bloom_input_precedes_target_cycle() {
let error = compile_value(self_targeting_composite("rgba8_unorm")).unwrap_err();
assert_eq!(error.code, "GRAPH_ILLEGAL_ACCESS");
assert_eq!(error.details["path"], "nodes[11].inputs");
assert_eq!(
compile_value(self_targeting_composite("rgba16_float"))
.unwrap_err()
.code,
"GRAPH_CYCLE"
);
}
fn cyclic_fullscreen_source(target_format: &str) -> Value {
let mut graph = full_cull_graph();
graph["nodes"]
.as_array_mut()
.unwrap()
.insert(9, texture("copy_target", target_format));
graph["nodes"].as_array_mut().unwrap().insert(
10,
node(
"source_cycle",
"fullscreen_copy",
1,
json!({}),
json!({
"source": input("pipeline", "color"),
"colorTarget": input("source_cycle", "color")
}),
),
);
graph["nodes"].as_array_mut().unwrap().insert(
11,
node(
"copy",
"fullscreen_copy",
1,
json!({}),
json!({
"source": input("source_cycle", "color"),
"colorTarget": input("copy_target", "texture")
}),
),
);
graph["nodes"][12]["inputs"]["color"] = input("copy", "color");
graph
}
#[test]
fn cyclic_fullscreen_source_defers_uninitialized_error() {
let error = compile_value(cyclic_fullscreen_source("depth32_float")).unwrap_err();
assert_eq!(error.code, "GRAPH_ILLEGAL_ACCESS");
assert_eq!(error.details["path"], "nodes[11].inputs");
assert_eq!(
compile_value(cyclic_fullscreen_source("rgba16_float"))
.unwrap_err()
.code,
"GRAPH_CYCLE"
);
}
fn cyclic_bloom_input(target_format: &str) -> Value {
let mut graph = full_cull_graph();
graph["nodes"]
.as_array_mut()
.unwrap()
.insert(9, texture("composite_target", target_format));
graph["nodes"].as_array_mut().unwrap().insert(
10,
node(
"bloom_cycle",
"fullscreen_copy",
1,
json!({}),
json!({
"source": input("pipeline", "color"),
"colorTarget": input("bloom_cycle", "color")
}),
),
);
graph["nodes"].as_array_mut().unwrap().insert(
11,
node(
"composite",
"bloom_composite",
1,
json!({"intensity":1}),
json!({
"source": input("pipeline", "color"),
"bloom": input("bloom_cycle", "color"),
"colorTarget": input("composite_target", "texture")
}),
),
);
graph["nodes"][12]["inputs"]["color"] = input("composite", "color");
graph
}
#[test]
fn cyclic_bloom_input_defers_uninitialized_error() {
let error = compile_value(cyclic_bloom_input("depth32_float")).unwrap_err();
assert_eq!(error.code, "GRAPH_ILLEGAL_ACCESS");
assert_eq!(error.details["path"], "nodes[11].inputs");
assert_eq!(
compile_value(cyclic_bloom_input("rgba16_float"))
.unwrap_err()
.code,
"GRAPH_CYCLE"
);
}
fn compiler_default_source(graph: &CompiledGraph) -> (usize, u32, u32) {
graph
.texture_families
.iter()
.enumerate()
.find_map(|(family_index, family)| match family.source {
TextureFamilySource::CompilerDefaultInput {
resource,
owner_node_index,
..
} => Some((family_index, resource, owner_node_index)),
_ => None,
})
.unwrap()
}
fn assert_runtime_plan_invalid(graph: &CompiledGraph) {
let error = validate_activatable(graph).unwrap_err();
assert_eq!(error.code, "GRAPH_RUNTIME_PLAN_INVALID");
}
#[test]
fn runtime_rejects_duplicate_compiler_default_owner_identity() {
let mut graph = compile_value(implicit_pipeline_graph()).unwrap();
assert!(validate_activatable(&graph).is_ok());
let (_, _, owner) = compiler_default_source(&graph);
graph
.executions
.iter_mut()
.find(|execution| execution.executor.key == "frame_out")
.unwrap()
.original_node_index = owner;
assert_runtime_plan_invalid(&graph);
}
#[test]
fn runtime_rejects_coherently_retagged_authored_texture_origin() {
let mut graph = compile_value(full_cull_graph()).unwrap();
assert!(validate_activatable(&graph).is_ok());
let family = graph
.texture_families
.iter_mut()
.find(|family| matches!(family.source, TextureFamilySource::AuthoredTexture { .. }))
.unwrap();
let TextureFamilySource::AuthoredTexture { resource, .. } = family.source else {
unreachable!()
};
family.key.source_node = 2;
family.key.source_socket = 1;
let source = &mut graph.resources[resource as usize];
source.original_node_index = 2;
source.origin = ResourceOrigin::AuthoredOutput {
node: "mesh".into(),
socket: "type".into(),
output_ordinal: 1,
};
assert_runtime_plan_invalid(&graph);
}
#[test]
fn runtime_rejects_duplicate_compiler_default_input_occurrence() {
let mut graph = compile_value(implicit_pipeline_graph()).unwrap();
assert!(validate_activatable(&graph).is_ok());
let (_, resource, owner) = compiler_default_source(&graph);
graph
.executions
.iter_mut()
.find(|execution| execution.original_node_index == owner)
.unwrap()
.inputs
.push(CompiledSocketInput {
socket: "duplicate".into(),
resource,
});
assert_runtime_plan_invalid(&graph);
}
#[test]
fn runtime_rejects_out_of_range_opposite_default_family_without_panicking() {
let mut graph = compile_value(implicit_pipeline_graph()).unwrap();
assert!(validate_activatable(&graph).is_ok());
let (_, _, owner) = compiler_default_source(&graph);
let opposite_resource = graph
.executions
.iter()
.find(|execution| execution.original_node_index == owner)
.unwrap()
.inputs
.iter()
.find(|input| input.socket == "depthTarget")
.unwrap()
.resource;
let out_of_range = graph.texture_families.len() as u32;
let ResourcePlan::TextureSource { family, .. } =
&mut graph.resources[opposite_resource as usize].plan
else {
panic!("expected opposite texture source")
};
*family = out_of_range;
assert_runtime_plan_invalid(&graph);
}