74 lines
2.3 KiB
Rust
74 lines
2.3 KiB
Rust
use crate::core::texture::{FloatTexture, SpectrumTexture};
|
|
use crate::core::texture::{FloatTextureTrait, SpectrumTextureTrait};
|
|
use crate::utils::{Arena, FileLoc, TextureParameterDictionary};
|
|
use shared::Float;
|
|
use shared::core::texture::TextureEvalContext;
|
|
use shared::spectra::{SampledSpectrum, SampledWavelengths};
|
|
use shared::utils::Transform;
|
|
use std::sync::Arc;
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct FloatScaledTexture {
|
|
pub tex: Arc<FloatTexture>,
|
|
pub scale: Arc<FloatTexture>,
|
|
}
|
|
|
|
impl FloatScaledTexture {
|
|
pub fn new(tex: Arc<FloatTexture>, scale: Arc<FloatTexture>) -> Self {
|
|
Self { tex, scale }
|
|
}
|
|
|
|
pub fn create(
|
|
_render_from_texture: &Transform,
|
|
params: &TextureParameterDictionary,
|
|
_loc: &FileLoc,
|
|
_arena: &mut Arena,
|
|
) -> FloatTexture {
|
|
let mut tex = params.get_float_texture("tex", 1.);
|
|
let mut scale = params.get_float_texture("scale", 1.);
|
|
|
|
for _ in 0..2 {
|
|
if let FloatTexture::Constant(c_tex) = &*scale {
|
|
let cs = c_tex.value;
|
|
if cs == 1.0 {
|
|
return (*tex).clone();
|
|
} else if let FloatTexture::Image(img_tex) = &*tex {
|
|
let mut image_copy = img_tex.clone();
|
|
image_copy.base.multiply_scale(cs);
|
|
return FloatTexture::Image(image_copy).into();
|
|
}
|
|
}
|
|
|
|
std::mem::swap(&mut tex, &mut scale);
|
|
}
|
|
std::mem::swap(&mut tex, &mut scale);
|
|
// arena.alloc(FloatScaledTexture::new(tex, scale));
|
|
FloatTexture::Scaled(FloatScaledTexture::new(tex.clone(), scale.clone()))
|
|
}
|
|
}
|
|
|
|
impl FloatTextureTrait for FloatScaledTexture {
|
|
fn evaluate(&self, ctx: &TextureEvalContext) -> Float {
|
|
let sc = self.scale.evaluate(ctx);
|
|
if sc == 0. {
|
|
return 0.;
|
|
}
|
|
self.tex.evaluate(ctx)
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct SpectrumScaledTexture {
|
|
pub tex: Arc<SpectrumTexture>,
|
|
pub scale: Arc<FloatTexture>,
|
|
}
|
|
|
|
impl SpectrumTextureTrait for SpectrumScaledTexture {
|
|
fn evaluate(&self, ctx: &TextureEvalContext, lambda: &SampledWavelengths) -> SampledSpectrum {
|
|
let sc = self.scale.evaluate(ctx);
|
|
if sc == 0. {
|
|
return SampledSpectrum::new(0.);
|
|
}
|
|
self.tex.evaluate(ctx, lambda) * sc
|
|
}
|
|
}
|