github/wgpu
1
1
Fork 0
mirror of https://github.com/gfx-rs/wgpu.git synced 2026-04-22 03:02:01 -04:00
Code Issues Packages Projects Releases Wiki Activity

[glsl-in] Add helper to reduce repetition. (#1505)

Browse Source 
```
Ok(self.constants.fetch_or_append(
    Constant {
        name: None,
        specialization: None,
        inner,
    },
    span,
))
```

was called repetitively, so I added
`ConstantSolver::register_constant(&mut self, ConstantInner, Span)`
that returns Handle<Constant>.
This commit is contained in:
Shohei Jinno
2021-11-02 18:05:59 -07:00
committed by GitHub
parent c1b378842e
commit d9b166816b
1 changed files with 19 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
src/front/glsl/constants.rs
View File

@@ -96,17 +96,11 @@ impl<'a> ConstantSolver<'a> {
}
};
Ok(self.constants.fetch_or_append(
Constant {
name: None,
specialization: None,
inner: ConstantInner::Composite {
ty,
components: vec![value_constant; size as usize],
},
},
span,
))
let inner = ConstantInner::Composite {
ty,
components: vec![value_constant; size as usize],
};
Ok(self.register_constant(inner, span))
}
Expression::Swizzle {
size,
@@ -146,30 +140,18 @@ impl<'a> ConstantSolver<'a> {
.iter()
.map(|&sc| src_components[sc as usize])
.collect();
let inner = ConstantInner::Composite { ty, components };
Ok(self.constants.fetch_or_append(
Constant {
name: None,
specialization: None,
inner: ConstantInner::Composite { ty, components },
},
span,
))
Ok(self.register_constant(inner, span))
}
Expression::Compose { ty, ref components } => {
let components = components
.iter()
.map(|c| self.solve(*c))
.collect::<Result<_, _>>()?;
let inner = ConstantInner::Composite { ty, components };
Ok(self.constants.fetch_or_append(
Constant {
name: None,
specialization: None,
inner: ConstantInner::Composite { ty, components },
},
span,
))
Ok(self.register_constant(inner, span))
}
Expression::Unary { expr, op } => {
let expr_constant = self.solve(expr)?;
@@ -216,14 +198,8 @@ impl<'a> ConstantSolver<'a> {
_ => return Err(ConstantSolvingError::InvalidMathArg),
};
Ok(self.constants.fetch_or_append(
Constant {
name: None,
specialization: None,
inner: ConstantInner::Scalar { width, value },
},
span,
))
let inner = ConstantInner::Scalar { width, value };
Ok(self.register_constant(inner, span))
}
_ => Err(ConstantSolvingError::NotImplemented(format!("{:?}", fun))),
}
@@ -357,14 +333,7 @@ impl<'a> ConstantSolver<'a> {
}
}
Ok(self.constants.fetch_or_append(
Constant {
name: None,
specialization: None,
inner,
},
span,
))
Ok(self.register_constant(inner, span))
}
fn unary_op(
@@ -404,14 +373,7 @@ impl<'a> ConstantSolver<'a> {
}
}
Ok(self.constants.fetch_or_append(
Constant {
name: None,
specialization: None,
inner,
},
span,
))
Ok(self.register_constant(inner, span))
}
fn binary_op(
@@ -514,14 +476,18 @@ impl<'a> ConstantSolver<'a> {
_ => return Err(ConstantSolvingError::InvalidBinaryOpArgs),
};
Ok(self.constants.fetch_or_append(
Ok(self.register_constant(inner, span))
}
fn register_constant(&mut self, inner: ConstantInner, span: crate::Span) -> Handle<Constant> {
self.constants.fetch_or_append(
Constant {
name: None,
specialization: None,
inner,
},
span,
))
)
}
}