public Spectrum ToSpectrum(IObjectArena arena)
{
var c = new float[_c.Length];
Array.Copy(_c, c, _c.Length);
return(arena.Create <Spectrum>().Initialize(c));
}
public void ComputeScatteringFunctions(SurfaceInteraction si,
IObjectArena arena,
TransportMode mode,
bool allowMultipleLobes)
{
BumpMap?.Bump(si);
var bsdf = si.BSDF.Initialize(in si);
var r = Kd.Evaluate(in si).Clamp();
if (r.IsBlack())
{
return;
}
var sig = Clamp(0, 90, Sigma.Evaluate(in si));
if (sig == 0f)
{
bsdf.Add(arena.Create <LambertianReflection>().Initialize(in r));
}
else
{
bsdf.Add(arena.Create <OrenNayar>().Initialize(in r, sig));
}
}
public static Spectrum UniformSampleOneLight(this Interaction it,
IScene scene,
IObjectArena arena,
ISampler sampler,
bool handleMedia = false,
Distribution1D lightDistribution = null)
{
var nLights = scene.Lights.Length;
if (nLights == 0)
{
return(Spectrum.Zero);
}
int lightNum;
float lightPdf;
if (!(lightDistribution is null))
{
lightNum = lightDistribution.SampleDiscrete(sampler.Get1D(), out lightPdf, out _);
if (lightPdf == 0f)
{
return(Spectrum.Zero);
}
}
public void ComputeScatteringFunctions(SurfaceInteraction si,
IObjectArena arena,
TransportMode mode,
bool allowMultipleLobes)
{
var s1 = Scale.Evaluate(in si).Clamp();
var s2 = (Spectrum.One - s1).Clamp();
M1.ComputeScatteringFunctions(si, arena, mode, allowMultipleLobes);
var si2 = arena.Create <SurfaceInteraction>().Initialize(in si);
M2.ComputeScatteringFunctions(si2, arena, mode, allowMultipleLobes);
var n1 = si.BSDF.NumberOfComponents();
var n2 = si2.BSDF.NumberOfComponents();
for (var i = 0; i < n1; ++i)
{
var collection = (IBxDFCollection)si.BSDF;
var bxdf = arena.Create <ScaledBxDF>().Initialize(collection[i], s1);
collection.Set(bxdf, i);
}
for (var i = 0; i < n2; ++i)
{
var collection = (IBxDFCollection)si2.BSDF;
var bxdf = arena.Create <ScaledBxDF>().Initialize(collection[i], s2);
collection.Set(bxdf, i);
}
}
public void ComputeScatteringFunctions(SurfaceInteraction si,
IObjectArena arena,
TransportMode mode,
bool allowMultipleLobes)
{
BumpMap?.Bump(si);
var bsdf = si.BSDF.Initialize(in si);
var kd = Kd.Evaluate(in si).Clamp();
if (!kd.IsBlack())
{
bsdf.Add(arena.Create <LambertianReflection>().Initialize(in kd));
}
var ks = Ks.Evaluate(in si).Clamp();
if (ks.IsBlack())
{
return;
}
var fresnel = arena.Create <FresnelDielectric>().Initialize(1.5f, 1f);
var rough = Roughness.Evaluate(in si);
if (RemapRoughness)
{
rough = TrowbridgeReitzDistribution.RoughnessToAlpha(rough);
}
var distribution = arena.Create <TrowbridgeReitzDistribution>().Initialize(rough, rough);
bsdf.Add(arena.Create <MicrofacetReflection>().Initialize(ks, distribution, fresnel));
}
public void ComputeScatteringFunctions(SurfaceInteraction si,
IObjectArena arena,
TransportMode mode,
bool allowMultipleLobes)
{
_bumpMap?.Bump(si);
si.BSDF.Initialize(si);
var R = _kr.Evaluate(si).Clamp();
if (!R.IsBlack())
{
si.BSDF.Add(arena.Create <SpecularReflection>().Initialize(R, arena.Create <FresnelNoOp>()));
}
}
public void ComputeScatteringFunctions(SurfaceInteraction si,
IObjectArena arena,
TransportMode mode,
bool allowMultipleLobes)
{
_bumpMap?.Bump(si);
si.BSDF.Initialize(si);
var uRough = _uRoughness?.Evaluate(si) ?? _roughness.Evaluate(si);
var vRough = _vRoughness?.Evaluate(si) ?? _roughness.Evaluate(si);
if (_remapRoughness)
{
uRough = TrowbridgeReitzDistribution.RoughnessToAlpha(uRough);
vRough = TrowbridgeReitzDistribution.RoughnessToAlpha(vRough);
}
var fr = arena.Create <FresnelConductor>().Initialize(Spectrum.One, _eta.Evaluate(si), _k.Evaluate(si));
var dist = arena.Create <TrowbridgeReitzDistribution>().Initialize(uRough, vRough);
si.BSDF.Add(arena.Create <MicrofacetReflection>().Initialize(Spectrum.One, dist, fr));
}
public void ComputeScatteringFunctions(SurfaceInteraction si,
IObjectArena arena,
TransportMode mode,
bool allowMultipleLobes)
{
BumpMap?.Bump(si);
si.BSDF.Initialize(si);
// Diffuse
var c = Color.Evaluate(si).Clamp();
var metallicWeight = Metallic.Evaluate(si);
var e = Eta.Evaluate(si);
var strans = SpecTrans.Evaluate(si);
var diffuseWeight = (1f - metallicWeight) * (1f - strans);
var dt = DiffTrans.Evaluate(si) / 2f;
var rough = Roughness.Evaluate(si);
var lum = c.YComponent();
var Ctint = lum > 0f ? c / lum : Spectrum.One;
if (diffuseWeight > 0f)
{
if (IsThin)
{
var flat = Flatness.Evaluate(si);
si.BSDF.Add(arena.Create <DisneyDiffuse>().Initialize(diffuseWeight * (1f - flat) * (1 - dt) * c));
si.BSDF.Add(arena.Create <DisneyFakeSS>().Initialize(diffuseWeight * flat * (1f - dt) * c, rough));
}
else
{
var sd = ScatterDistance.Evaluate(si);
if (sd.IsBlack())
{
si.BSDF.Add(arena.Create <DisneyDiffuse>().Initialize(diffuseWeight * c));
}
else
{
// The line below was the original code but produces some odd results.
si.BSDF.Add(arena.Create <SpecularTransmission>().Initialize(Spectrum.One, 1f, e, mode));
si.BSSRDF = arena.Create <DisneyBSSRDF>().Initialize(diffuseWeight * c, sd, si, e, this, mode);
}
}
// Retro-reflection.
si.BSDF.Add(arena.Create <DisneyRetro>().Initialize(diffuseWeight * c, rough));
// Sheen
var sheenWeight = Sheen.Evaluate(si);
if (sheenWeight > 0f)
{
var stint = SheenTint.Evaluate(si);
var Csheen = Spectrum.Lerp(Spectrum.One, Ctint, stint);
si.BSDF.Add(arena.Create <DisneySheen>().Initialize(diffuseWeight * sheenWeight * Csheen));
}
}
// Microfacet distribution
var aspect = Sqrt(1f - Anisotropic.Evaluate(si) * 0.9f);
var ax = Max(0.001f, Sqr(rough) / aspect);
var ay = Max(0.001f, Sqr(rough) * aspect);
var dist = arena.Create <DisneyMicrofacetDistribution>().Initialize(ax, ay);
// Specular = Trowbridge-Reitz with modified Fresnel function.
var specTint = SpecularTint.Evaluate(si);
var Cspec0 = Spectrum.Lerp(SchlickR0FromEta(e) * Spectrum.Lerp(Spectrum.One, Ctint, specTint), c,
metallicWeight);
var fresnel = arena.Create <DisneyFresnel>().Initialize(Cspec0, metallicWeight, e);
si.BSDF.Add(arena.Create <MicrofacetReflection>().Initialize(c, dist, fresnel));
// Clearcoat
var cc = Clearcoat.Evaluate(si);
if (cc > 0f)
{
si.BSDF.Add(arena.Create <DisneyClearcoat>()
.Initialize(cc, Lerp(0.1f, 0.001f, ClearcoatGloss.Evaluate(si))));
}
// BTDF
if (strans > 0f)
{
// Walter et al's model, with the provided transmissive term scaled
// by sqrt(color), so that after two refractions, we're back to the
// provided color.
var T = strans * c.Sqrt();
if (IsThin)
{
var rScaled = (0.65f * e - 0.35f) * rough;
var atx = Max(0.001f, Sqr(rScaled) / aspect);
var aty = Max(0.001f, Sqr(rScaled) * aspect);
var scaledDist = arena.Create <TrowbridgeReitzDistribution>().Initialize(atx, aty);
si.BSDF.Add(arena.Create <MicrofacetTransmission>().Initialize(T, scaledDist, 1f, e, mode));
}
else
{
si.BSDF.Add(arena.Create <MicrofacetTransmission>().Initialize(T, dist, 1f, e, mode));
}
}
if (IsThin)
{
si.BSDF.Add(arena.Create <LambertianTransmission>().Initialize(dt * c));
}
}
public void ComputeScatteringFunctions(SurfaceInteraction surfaceInteraction,
IObjectArena arena,
TransportMode mode,
in bool allowMultipleLobes)
public override ISampler Clone(int seed, IObjectArena arena)
{
return(arena.Create <RandomSampler>().Initialize(this, seed));
// return new RandomSampler(this, seed);
}
