// PlasticMaterial Method Definitions
BSDF *PlasticMaterial::GetBSDF(const DifferentialGeometry &dgGeom,
const DifferentialGeometry &dgShading,
MemoryArena &arena) const {
// Allocate _BSDF_, possibly doing bump mapping with _bumpMap_
DifferentialGeometry dgs;
if (bumpMap)
Bump(bumpMap, dgGeom, dgShading, &dgs);
else
dgs = dgShading;
BSDF *bsdf = BSDF_ALLOC(arena, BSDF)(dgs, dgGeom.nn);
Spectrum kd = Kd->Evaluate(dgs).Clamp();
if (!kd.IsBlack()) {
BxDF *diff = BSDF_ALLOC(arena, Lambertian)(kd);
bsdf->Add(diff);
}
Spectrum ks = Ks->Evaluate(dgs).Clamp();
if (!ks.IsBlack()) {
Fresnel *fresnel = BSDF_ALLOC(arena, FresnelDielectric)(1.5f, 1.f);
float rough = roughness->Evaluate(dgs);
BxDF *spec = BSDF_ALLOC(arena, Microfacet)
(ks, fresnel, BSDF_ALLOC(arena, Blinn)(1.f / rough));
bsdf->Add(spec);
}
return bsdf;
}
// MirrorMaterial Method Definitions
BSDF *MirrorMaterial::GetBSDF(const DifferentialGeometry &dgGeom, const DifferentialGeometry &dgShading, MemoryArena &arena) const {
// Allocate _BSDF_, possibly doing bump mapping with _bumpMap_
DifferentialGeometry dgs;
if (bumpMap)
Bump(bumpMap, dgGeom, dgShading, &dgs);
else
dgs = dgShading;
BSDF *bsdf = BSDF_ALLOC(arena, BSDF)(dgs, dgGeom.nn);
Spectrum R = Kr->Evaluate(dgs).Clamp();
if (!R.IsBlack()) {
float x,y,z;
x = dgs.p.x;
y = dgs.p.y;
z = dgs.p.z;
float rad = sqrt((x-(-4))*(x-(-4)) + (y-1)*(y-1) + (z-15)*(z-15));
float c = 15.f;
// if (rad < c) {// 11->20, 14
bsdf->Add(BSDF_ALLOC(arena, SpecularReflection)(R,
BSDF_ALLOC(arena, FresnelNoOp)()));
// } else {
// bsdf->Add(BSDF_ALLOC(arena, SpecularReflection)(R,
// BSDF_ALLOC(arena, FresnelNoOp)()));
// }
}
return bsdf;
}
// BrushedMetal Method Definitions
BSDF *BrushedMetal::GetBSDF(const DifferentialGeometry &dgGeom, const DifferentialGeometry &dgShading) const {
// Declare brushedmetal coefficients
static float diffuse[3] = { 0, 0, 0 };
static float xy0[3] = { -1.11854f, -1.11845f, -1.11999f };
static float z0[3] = { 1.01272f, 1.01469f, 1.01942f };
static float e0[3] = { 15.8708f, 15.6489f, 15.4571f };
static float xy1[3] = { -1.05334f, -1.06409f, -1.08378f };
static float z1[3] = { 0.69541f, 0.662178f, 0.626672f };
static float e1[3] = { 111.267f, 88.9222f, 65.2179f };
static float xy2[3] = { -1.01684f, -1.01635f, -1.01529f };
static float z2[3] = { 1.00132f, 1.00112f, 1.00108f };
static float e2[3] = { 180.181f, 184.152f, 195.773f };
static Spectrum xy[3] = { Spectrum(xy0), Spectrum(xy1), Spectrum(xy2) };
static Spectrum z[3] = { Spectrum(z0), Spectrum(z1), Spectrum(z2) };
static Spectrum e[3] = { Spectrum(e0), Spectrum(e1), Spectrum(e2) };
// Allocate _BSDF_, possibly doing bump-mapping with _bumpMap_
DifferentialGeometry dgs;
if (bumpMap)
Bump(bumpMap, dgGeom, dgShading, &dgs);
else
dgs = dgShading;
BSDF *bsdf = BSDF_ALLOC(BSDF)(dgs, dgGeom.nn);
bsdf->Add(BSDF_ALLOC(Lafortune)(Spectrum(*diffuse), 3, xy, xy, z, e,
BxDFType(BSDF_REFLECTION | BSDF_GLOSSY)));
return bsdf;
}
// BluePaint Method Definitions
BSDF *BluePaint::GetBSDF(const DifferentialGeometry &dgGeom, const DifferentialGeometry &dgShading) const {
// Declare bluepaint coefficients
static float diffuse[3] = { 0.3094f, 0.39667f, 0.70837f };
static float xy0[3] = { 0.870567f, 0.857255f, 0.670982f };
static float z0[3] = { 0.803624f, 0.774290f, 0.586674f };
static float e0[3] = { 21.820103f, 18.597755f, 7.472717f };
static float xy1[3] = { -0.451218f, -0.406681f, -0.477976f };
static float z1[3] = { 0.023123f, 0.017625f, 0.227295f };
static float e1[3] = { 2.774499f, 2.581499f, 3.677653f };
static float xy2[3] = { -1.031545f, -1.029426f, -1.026588f };
static float z2[3] = { 0.706734f, 0.696530f, 0.687715f };
static float e2[3] = { 66.899060f, 63.767912f, 57.489181f };
static Spectrum xy[3] = { Spectrum(xy0), Spectrum(xy1), Spectrum(xy2) };
static Spectrum z[3] = { Spectrum(z0), Spectrum(z1), Spectrum(z2) };
static Spectrum e[3] = { Spectrum(e0), Spectrum(e1), Spectrum(e2) };
// Allocate _BSDF_, possibly doing bump-mapping with _bumpMap_
DifferentialGeometry dgs;
if (bumpMap)
Bump(bumpMap, dgGeom, dgShading, &dgs);
else
dgs = dgShading;
BSDF *bsdf = BSDF_ALLOC(BSDF)(dgs, dgGeom.nn);
bsdf->Add(BSDF_ALLOC(Lafortune)(Spectrum(diffuse), 3, xy, xy, z, e,
BxDFType(BSDF_REFLECTION | BSDF_DIFFUSE)));
return bsdf;
}
// KdSubsurfaceMaterial Method Definitions
void KdSubsurfaceMaterial::ComputeScatteringFunctions(
SurfaceInteraction *si, MemoryArena &arena, TransportMode mode,
bool allowMultipleLobes) const {
// Perform bump mapping with _bumpMap_, if present
if (bumpMap) Bump(bumpMap, si);
si->bsdf = ARENA_ALLOC(arena, BSDF)(*si, eta);
Spectrum R = Kr->Evaluate(*si).Clamp();
Spectrum T = Kt->Evaluate(*si).Clamp();
if (allowMultipleLobes && (!R.IsBlack() || !T.IsBlack()))
si->bsdf->Add(
ARENA_ALLOC(arena, FresnelSpecular)(1., 1., 1.f, eta, mode));
else {
if (!R.IsBlack())
si->bsdf->Add(ARENA_ALLOC(arena, SpecularReflection)(
R, ARENA_ALLOC(arena, FresnelDielectric)(1.f, eta)));
if (!T.IsBlack())
si->bsdf->Add(
ARENA_ALLOC(arena, SpecularTransmission)(T, 1.f, eta, mode));
}
Spectrum sig_t = scale * sigma_t->Evaluate(*si).Clamp();
Spectrum kd = Kd->Evaluate(*si).Clamp();
Spectrum sig_a, sig_s;
SubsurfaceFromDiffuse(table, kd, sig_t, &sig_a, &sig_s);
si->bssrdf = ARENA_ALLOC(arena, TabulatedBSSRDF)(*si, this, mode, eta,
sig_a, sig_s, table);
}
// Primer Method Definitions
BSDF *Primer::GetBSDF(const DifferentialGeometry &dgGeom, const DifferentialGeometry &dgShading) const {
// Declare primer coefficients
static float diffuse[3] = { 0.118230f, 0.121218f, 0.133209f};
static float xy0[3] = { -0.399286f, -1.033473f, -1.058104f};
static float z0[3] = { 0.167504f, 0.009545f, -0.068002f};
static float e0[3] = { 2.466633f, 7.637253f, 8.117645f};
static float xy1[3] = { -1.041861f, -1.100108f, -1.087779f};
static float z1[3] = { 0.014375f, -0.198147f, -0.053605f};
static float e1[3] = { 7.993722f, 29.446268f, 41.988990f};
static float xy2[3] = { -1.098605f, -0.379883f, -0.449038f};
static float z2[3] = { -0.145110f, 0.159127f, 0.173224f};
static float e2[3] = { 31.899719f, 2.372852f, 2.636161f};
static Spectrum xy[3] = { Spectrum(xy0), Spectrum(xy1), Spectrum(xy2) };
static Spectrum z[3] = { Spectrum(z0), Spectrum(z1), Spectrum(z2) };
static Spectrum e[3] = { Spectrum(e0), Spectrum(e1), Spectrum(e2) };
// Allocate _BSDF_, possibly doing bump-mapping with _bumpMap_
DifferentialGeometry dgs;
if (bumpMap)
Bump(bumpMap, dgGeom, dgShading, &dgs);
else
dgs = dgShading;
BSDF *bsdf = BSDF_ALLOC(BSDF)(dgs, dgGeom.nn);
bsdf->Add(BSDF_ALLOC(Lafortune)(Spectrum(diffuse), 3, xy, xy, z, e,
BxDFType(BSDF_REFLECTION | BSDF_DIFFUSE)));
return bsdf;
}
// Felt Method Definitions
BSDF *Felt::GetBSDF(const DifferentialGeometry &dgGeom, const DifferentialGeometry &dgShading) const {
// Declare felt coefficients
static float diffuse[3] = { 0.025865f, 0.025865f, 0.025865f};
static float xy0[3] = { -0.304075f, -0.304075f, -0.304075f};
static float z0[3] = { -0.065992f, -0.065992f, -0.065992f};
static float e0[3] = { 3.047892f, 3.047892f, 3.047892f};
static float xy1[3] = { -0.749561f, -0.749561f, -0.749561f};
static float z1[3] = { -1.167929f, -1.167929f, -1.167929f};
static float e1[3] = { 6.931827f, 6.931827f, 6.931827f};
static float xy2[3] = { 1.004921f, 1.004921f, 1.004921f};
static float z2[3] = { -0.205529f, -0.205529f, -0.205529f};
static float e2[3] = { 94.117332f, 94.117332f, 94.117332f};
static Spectrum xy[3] = { Spectrum(xy0), Spectrum(xy1), Spectrum(xy2) };
static Spectrum z[3] = { Spectrum(z0), Spectrum(z1), Spectrum(z2) };
static Spectrum e[3] = { Spectrum(e0), Spectrum(e1), Spectrum(e2) };
// Allocate _BSDF_, possibly doing bump-mapping with _bumpMap_
DifferentialGeometry dgs;
if (bumpMap)
Bump(bumpMap, dgGeom, dgShading, &dgs);
else
dgs = dgShading;
BSDF *bsdf = BSDF_ALLOC(BSDF)(dgs, dgGeom.nn);
bsdf->Add(BSDF_ALLOC(Lafortune)(Spectrum(diffuse), 3, xy, xy, z, e,
BxDFType(BSDF_REFLECTION | BSDF_DIFFUSE)));
return bsdf;
}
// TranslucentMaterial Method Definitions
BSDF *TranslucentMaterial::GetBSDF(const DifferentialGeometry &dgGeom, const DifferentialGeometry &dgShading, MemoryArena &arena) const {
float ior = 1.5f;
DifferentialGeometry dgs;
if (bumpMap)
Bump(bumpMap, dgGeom, dgShading, &dgs);
else
dgs = dgShading;
BSDF *bsdf = BSDF_ALLOC(arena, BSDF)(dgs, dgGeom.nn, ior);
Spectrum r = reflect->Evaluate(dgs).Clamp();
Spectrum t = transmit->Evaluate(dgs).Clamp();
if (r.IsBlack() && t.IsBlack()) return bsdf;
Spectrum kd = Kd->Evaluate(dgs).Clamp();
if (!kd.IsBlack()) {
if (!r.IsBlack()) bsdf->Add(BSDF_ALLOC(arena, Lambertian)(r * kd));
if (!t.IsBlack()) bsdf->Add(BSDF_ALLOC(arena, BRDFToBTDF)(BSDF_ALLOC(arena, Lambertian)(t * kd)));
}
Spectrum ks = Ks->Evaluate(dgs).Clamp();
if (!ks.IsBlack()) {
float rough = roughness->Evaluate(dgs);
if (!r.IsBlack()) {
Fresnel *fresnel = BSDF_ALLOC(arena, FresnelDielectric)(ior, 1.f);
bsdf->Add(BSDF_ALLOC(arena, Microfacet)(r * ks, fresnel,
BSDF_ALLOC(arena, Blinn)(1.f / rough)));
}
if (!t.IsBlack()) {
Fresnel *fresnel = BSDF_ALLOC(arena, FresnelDielectric)(ior, 1.f);
bsdf->Add(BSDF_ALLOC(arena, BRDFToBTDF)(BSDF_ALLOC(arena, Microfacet)(t * ks, fresnel,
BSDF_ALLOC(arena, Blinn)(1.f / rough))));
}
}
return bsdf;
}
// Skin Method Definitions
BSDF *Skin::GetBSDF(const DifferentialGeometry &dgGeom, const DifferentialGeometry &dgShading) const {
// Declare skin coefficients
static float diffuse[3] = { 0.428425f, 0.301341f, 0.331054f};
static float xy0[3] = { -1.131747f, -1.016939f, -0.966018f};
static float z0[3] = { -1.209182f, -1.462488f, -1.222419f};
static float e0[3] = { 6.421658f, 3.699932f, 3.524889f};
static float xy1[3] = { -0.546570f, -0.643533f, -0.638934f};
static float z1[3] = { 0.380123f, 0.410559f, 0.437367f};
static float e1[3] = { 3.685044f, 4.266495f, 4.539742f};
static float xy2[3] = { -0.998888f, -1.020153f, -1.027479f};
static float z2[3] = { 0.857998f, 0.703913f, 0.573625f};
static float e2[3] = { 64.208486f, 63.919687f, 43.809866f};
static Spectrum xy[3] = { Spectrum(xy0), Spectrum(xy1), Spectrum(xy2) };
static Spectrum z[3] = { Spectrum(z0), Spectrum(z1), Spectrum(z2) };
static Spectrum e[3] = { Spectrum(e0), Spectrum(e1), Spectrum(e2) };
// Allocate _BSDF_, possibly doing bump-mapping with _bumpMap_
DifferentialGeometry dgs;
if (bumpMap)
Bump(bumpMap, dgGeom, dgShading, &dgs);
else
dgs = dgShading;
BSDF *bsdf = BSDF_ALLOC(BSDF)(dgs, dgGeom.nn);
bsdf->Add(BSDF_ALLOC(Lafortune)(Spectrum(diffuse), 3, xy, xy, z, e,
BxDFType(BSDF_REFLECTION | BSDF_DIFFUSE)));
return bsdf;
}
// custom_material Method Definitions
BSDF *custom_material::GetBSDF(const DifferentialGeometry &dgGeom,
const DifferentialGeometry &dgShading) const {
//issue debugging warning
//Warning("custom_material\n");
//declare geometry that will be used in BRDF
DifferentialGeometry dgs;
//if there is to be a bump map, call Bump, which modifies dgs
if (bumpMap)
Bump(bumpMap, dgGeom, dgShading, &dgs);
else
dgs = dgShading;
//allocate memory for BSDF, poiting bsdf to a new BSDF
BSDF *bsdf = BSDF_ALLOC(BSDF)(dgs, dgGeom.nn);
//set a spectrum kd to the spectrum stored in texure Kd
//***gets color spectrum of diffuse reflection***
Spectrum kd = Kd->Evaluate(dgs).Clamp();
//allocate to diff a custom BxDF with reflection spectrum kd
//***diffuse reflection characteristics***
BxDF *diff = BSDF_ALLOC(custom_BxDF3)(kd);
/* commented dpl 10 august 2005
// specular reflectance from pbrt's plastic model
//allocate to (temp) fresnes a fresneldielectric bsdf with
//parameters (1.5, 1)
//***will set part of specular reflection properties***
Fresnel *fresnel =
BSDF_ALLOC(FresnelDielectric)(1.5f, 1.f);
//set a spectrum ks to the spectrum stored in the texture Ks
//***gets color spectrum of specular reflection***
Spectrum ks = Ks->Evaluate(dgs).Clamp();
//get the roughness from roughness (?)
float rough = roughness->Evaluate(dgs);
//allocate memory for specular reflection BSDF
//***sets specular BSDF according to microfacet model
//with color params ks, fresnel and blinn models (?) ***
BxDF *spec = BSDF_ALLOC(Microfacet)(ks, fresnel,
BSDF_ALLOC(Blinn)(1.f / rough));
*/
//my specular reflectance
Spectrum ks = Ks->Evaluate(dgs).Clamp();
BxDF *spec = BSDF_ALLOC(custom_BxDF2)(ks);
//add both diff and spec BSDFS to the BSDF of this material
//***sets the BSDF of this material
bsdf->Add(diff);
bsdf->Add(spec);
return bsdf;
}
// UberMaterial Method Definitions
void UberMaterial::ComputeScatteringFunctions(SurfaceInteraction *si,
MemoryArena &arena,
TransportMode mode,
bool allowMultipleLobes) const {
// Perform bump mapping with _bumpMap_, if present
if (bumpMap) Bump(bumpMap, si);
Float e = eta->Evaluate(*si);
Spectrum op = opacity->Evaluate(*si).Clamp();
if (op != Spectrum(1.f)) {
si->bsdf = ARENA_ALLOC(arena, BSDF)(*si, 1.f);
BxDF *tr = ARENA_ALLOC(arena, SpecularTransmission)(-op + Spectrum(1.f),
1.f, 1.f, mode);
si->bsdf->Add(tr);
} else
si->bsdf = ARENA_ALLOC(arena, BSDF)(*si, e);
Spectrum kd = op * Kd->Evaluate(*si).Clamp();
if (!kd.IsBlack()) {
BxDF *diff = ARENA_ALLOC(arena, LambertianReflection)(kd);
si->bsdf->Add(diff);
}
Spectrum ks = op * Ks->Evaluate(*si).Clamp();
if (!ks.IsBlack()) {
Fresnel *fresnel = ARENA_ALLOC(arena, FresnelDielectric)(1.f, e);
Float roughu, roughv;
if (roughnessu)
roughu = roughnessu->Evaluate(*si);
else
roughu = roughness->Evaluate(*si);
if (roughnessv)
roughv = roughnessv->Evaluate(*si);
else
roughv = roughu;
if (remapRoughness) {
roughu = TrowbridgeReitzDistribution::RoughnessToAlpha(roughu);
roughv = TrowbridgeReitzDistribution::RoughnessToAlpha(roughv);
}
MicrofacetDistribution *distrib =
ARENA_ALLOC(arena, TrowbridgeReitzDistribution)(roughu, roughv);
BxDF *spec =
ARENA_ALLOC(arena, MicrofacetReflection)(ks, distrib, fresnel);
si->bsdf->Add(spec);
}
Spectrum kr = op * Kr->Evaluate(*si).Clamp();
if (!kr.IsBlack()) {
Fresnel *fresnel = ARENA_ALLOC(arena, FresnelDielectric)(1.f, e);
si->bsdf->Add(ARENA_ALLOC(arena, SpecularReflection)(kr, fresnel));
}
Spectrum kt = op * Kt->Evaluate(*si).Clamp();
if (!kt.IsBlack())
si->bsdf->Add(
ARENA_ALLOC(arena, SpecularTransmission)(kt, 1.f, e, mode));
}
void FourierMaterial::ComputeScatteringFunctions(
SurfaceInteraction *si, MemoryArena &arena, TransportMode mode,
bool allowMultipleLobes) const {
// Perform bump mapping with _bumpMap_, if present
if (bumpMap) Bump(bumpMap, si);
si->bsdf = ARENA_ALLOC(arena, BSDF)(*si);
// Checking for zero channels works as a proxy for checking whether the
// table was successfully read from the file.
if (bsdfTable.nChannels > 0)
si->bsdf->Add(ARENA_ALLOC(arena, FourierBSDF)(bsdfTable, mode));
}
// KdSubsurfaceMaterial Method Definitions
void KdSubsurfaceMaterial::ComputeScatteringFunctions(
SurfaceInteraction *si, MemoryArena &arena, TransportMode mode,
bool allowMultipleLobes) const {
// Perform bump mapping with _bumpMap_, if present
if (bumpMap) Bump(bumpMap, si);
Spectrum R = Kr->Evaluate(*si).Clamp();
Spectrum T = Kt->Evaluate(*si).Clamp();
Float urough = uRoughness->Evaluate(*si);
Float vrough = vRoughness->Evaluate(*si);
// Initialize _bsdf_ for smooth or rough dielectric
si->bsdf = ARENA_ALLOC(arena, BSDF)(*si, eta);
if (R.IsBlack() && T.IsBlack()) return;
bool isSpecular = urough == 0 && vrough == 0;
if (isSpecular && allowMultipleLobes) {
si->bsdf->Add(
ARENA_ALLOC(arena, FresnelSpecular)(R, T, 1.f, eta, mode));
} else {
if (remapRoughness) {
urough = TrowbridgeReitzDistribution::RoughnessToAlpha(urough);
vrough = TrowbridgeReitzDistribution::RoughnessToAlpha(vrough);
}
MicrofacetDistribution *distrib =
isSpecular ? nullptr
: ARENA_ALLOC(arena, TrowbridgeReitzDistribution)(
urough, vrough);
if (!R.IsBlack()) {
Fresnel *fresnel = ARENA_ALLOC(arena, FresnelDielectric)(1.f, eta);
if (isSpecular)
si->bsdf->Add(
ARENA_ALLOC(arena, SpecularReflection)(R, fresnel));
else
si->bsdf->Add(ARENA_ALLOC(arena, MicrofacetReflection)(
R, distrib, fresnel));
}
if (!T.IsBlack()) {
if (isSpecular)
si->bsdf->Add(ARENA_ALLOC(arena, SpecularTransmission)(
T, 1.f, eta, mode));
else
si->bsdf->Add(ARENA_ALLOC(arena, MicrofacetTransmission)(
T, distrib, 1.f, eta, mode));
}
}
Spectrum mfree = scale * mfp->Evaluate(*si).Clamp();
Spectrum kd = Kd->Evaluate(*si).Clamp();
Spectrum sig_a, sig_s;
SubsurfaceFromDiffuse(table, kd, Spectrum(1.f) / mfree, &sig_a, &sig_s);
si->bssrdf = ARENA_ALLOC(arena, TabulatedBSSRDF)(*si, this, mode, eta,
sig_a, sig_s, table);
}
void CObject::RandomBump (fix xScale, fix xForce, bool bSound)
{
fix angle;
angle = (d_rand () - I2X (1) / 4);
mType.physInfo.rotVel [X] += FixMul (angle, xScale);
angle = (d_rand () - I2X (1) / 4);
mType.physInfo.rotVel [Z] += FixMul (angle, xScale);
CFixVector vRand = CFixVector::Random ();
Bump (vRand, xForce);
if (bSound)
audio.CreateObjectSound (SOUND_PLAYER_HIT_WALL, SOUNDCLASS_GENERIC, Index ());
}
// Mirror Method Definitions
BSDF *Mirror::GetBSDF(const DifferentialGeometry &dgGeom, const DifferentialGeometry &dgShading) const {
// Allocate _BSDF_, possibly doing bump-mapping with _bumpMap_
DifferentialGeometry dgs;
if (bumpMap)
Bump(bumpMap, dgGeom, dgShading, &dgs);
else
dgs = dgShading;
BSDF *bsdf = BSDF_ALLOC(BSDF)(dgs, dgGeom.nn);
Spectrum R = Kr->Evaluate(dgs).Clamp();
if (!R.Black())
bsdf->Add(BSDF_ALLOC(SpecularReflection)(R,
BSDF_ALLOC(FresnelNoOp)()));
return bsdf;
}
// Substrate Method Definitions
BSDF *Substrate::GetBSDF(const DifferentialGeometry &dgGeom, const DifferentialGeometry &dgShading) const {
// Allocate _BSDF_, possibly doing bump-mapping with _bumpMap_
DifferentialGeometry dgs;
if (bumpMap)
Bump(bumpMap, dgGeom, dgShading, &dgs);
else
dgs = dgShading;
BSDF *bsdf = BSDF_ALLOC(BSDF)(dgs, dgGeom.nn);
Spectrum d = Kd->Evaluate(dgs).Clamp();
Spectrum s = Ks->Evaluate(dgs).Clamp();
float u = nu->Evaluate(dgs);
float v = nv->Evaluate(dgs);
bsdf->Add(BSDF_ALLOC(FresnelBlend)(d, s, BSDF_ALLOC(Anisotropic)(1.f/u, 1.f/v)));
return bsdf;
}
// GlassMaterial Method Definitions
void GlassMaterial::ComputeScatteringFunctions(SurfaceInteraction *si,
MemoryArena &arena,
TransportMode mode,
bool allowMultipleLobes) const {
// Perform bump mapping with _bumpMap_, if present
if (bumpMap) Bump(bumpMap, si);
Float eta = index->Evaluate(*si);
si->bsdf = ARENA_ALLOC(arena, BSDF)(*si, eta);
Spectrum R = Kr->Evaluate(*si).Clamp();
Spectrum T = Kt->Evaluate(*si).Clamp();
if (R.IsBlack() && T.IsBlack()) return;
Float urough = uRoughness->Evaluate(*si);
Float vrough = vRoughness->Evaluate(*si);
bool isSpecular = urough == 0 && vrough == 0;
if (isSpecular && allowMultipleLobes) {
si->bsdf->Add(
ARENA_ALLOC(arena, FresnelSpecular)(R, T, 1.f, eta, mode));
} else {
if (remapRoughness) {
urough = TrowbridgeReitzDistribution::RoughnessToAlpha(urough);
vrough = TrowbridgeReitzDistribution::RoughnessToAlpha(vrough);
}
MicrofacetDistribution *distrib =
isSpecular ? nullptr
: ARENA_ALLOC(arena, TrowbridgeReitzDistribution)(
urough, vrough);
if (!R.IsBlack()) {
Fresnel *fresnel = ARENA_ALLOC(arena, FresnelDielectric)(1.f, eta);
if (isSpecular)
si->bsdf->Add(
ARENA_ALLOC(arena, SpecularReflection)(R, fresnel));
else
si->bsdf->Add(ARENA_ALLOC(arena, MicrofacetReflection)(
R, distrib, fresnel));
}
if (!T.IsBlack()) {
if (isSpecular)
si->bsdf->Add(ARENA_ALLOC(arena, SpecularTransmission)(
T, 1.f, eta, mode));
else
si->bsdf->Add(ARENA_ALLOC(arena, MicrofacetTransmission)(
T, distrib, 1.f, eta, mode));
}
}
}
BSDF *MeasuredMaterial::GetBSDF(const DifferentialGeometry &dgGeom,
const DifferentialGeometry &dgShading,
MemoryArena &arena) const {
// Allocate _BSDF_, possibly doing bump mapping with _bumpMap_
DifferentialGeometry dgs;
if (bumpMap)
Bump(bumpMap, dgGeom, dgShading, &dgs);
else
dgs = dgShading;
BSDF *bsdf = BSDF_ALLOC(arena, BSDF)(dgs, dgGeom.nn);
if (regularHalfangleData)
bsdf->Add(BSDF_ALLOC(arena, RegularHalfangleBRDF)
(regularHalfangleData, nThetaH, nThetaD, nPhiD));
else if (thetaPhiData)
bsdf->Add(BSDF_ALLOC(arena, IrregIsotropicBRDF)(thetaPhiData));
return bsdf;
}
// KdSubsurfaceMaterial Method Definitions
BSDF *KdSubsurfaceMaterial::GetBSDF(const DifferentialGeometry &dgGeom,
const DifferentialGeometry &dgShading,
MemoryArena &arena) const {
// Allocate _BSDF_, possibly doing bump mapping with _bumpMap_
DifferentialGeometry dgs;
if (bumpMap)
Bump(bumpMap, dgGeom, dgShading, &dgs);
else
dgs = dgShading;
BSDF *bsdf = BSDF_ALLOC(arena, BSDF)(dgs, dgGeom.nn);
Spectrum R = Kr->Evaluate(dgs).Clamp();
float ior = index->Evaluate(dgs);
if (!R.IsBlack())
bsdf->Add(BSDF_ALLOC(arena, SpecularReflection)(R,
BSDF_ALLOC(arena, FresnelDielectric)(1., ior)));
return bsdf;
}
BSDF *MetalMaterial::GetBSDF(const DifferentialGeometry &dgGeom,
const DifferentialGeometry &dgShading, MemoryArena &arena) const {
// Allocate _BSDF_, possibly doing bump mapping with _bumpMap_
DifferentialGeometry dgs;
if (bumpMap)
Bump(bumpMap, dgGeom, dgShading, &dgs);
else
dgs = dgShading;
BSDF *bsdf = BSDF_ALLOC(arena, BSDF)(dgs, dgGeom.nn);
float rough = roughness->Evaluate(dgs);
MicrofacetDistribution *md = BSDF_ALLOC(arena, Blinn)(1.f / rough);
Fresnel *frMf = BSDF_ALLOC(arena, FresnelConductor)(eta->Evaluate(dgs),
k->Evaluate(dgs));
bsdf->Add(BSDF_ALLOC(arena, Microfacet)(1., frMf, md));
return bsdf;
}
// Matte Method Definitions
BSDF *danMatte::GetBSDF(const DifferentialGeometry &dgGeom,
const DifferentialGeometry &dgShading) const {
// Allocate _BSDF_, possibly doing bump-mapping with _bumpMap_
DifferentialGeometry dgs;
if (bumpMap)
Bump(bumpMap, dgGeom, dgShading, &dgs);
else
dgs = dgShading;
BSDF *bsdf = BSDF_ALLOC(BSDF)(dgs, dgGeom.nn);
// Evaluate textures for _Matte_ material and allocate BRDF
Spectrum r = Kd->Evaluate(dgs).Clamp();
float sig = Clamp(sigma->Evaluate(dgs), 0.f, 90.f);
if (sig == 0.)
bsdf->Add(BSDF_ALLOC(Lambertian)(r));
else
bsdf->Add(BSDF_ALLOC(OrenNayar)(r, sig));
return bsdf;
return bsdf;
}
// UberMaterial Method Definitions
BSDF *UberMaterial::GetBSDF(const DifferentialGeometry &dgGeom, const DifferentialGeometry &dgShading, MemoryArena &arena) const {
// Allocate _BSDF_, possibly doing bump mapping with _bumpMap_
DifferentialGeometry dgs;
if (bumpMap)
Bump(bumpMap, dgGeom, dgShading, &dgs);
else
dgs = dgShading;
BSDF *bsdf = BSDF_ALLOC(arena, BSDF)(dgs, dgGeom.nn);
Spectrum op = opacity->Evaluate(dgs).Clamp();
if (op != Spectrum(1.)) {
BxDF *tr = BSDF_ALLOC(arena, SpecularTransmission)(-op + Spectrum(1.), 1., 1.);
bsdf->Add(tr);
}
Spectrum kd = op * Kd->Evaluate(dgs).Clamp();
if (!kd.IsBlack()) {
BxDF *diff = BSDF_ALLOC(arena, Lambertian)(kd);
bsdf->Add(diff);
}
float e = eta->Evaluate(dgs);
Spectrum ks = op * Ks->Evaluate(dgs).Clamp();
if (!ks.IsBlack()) {
Fresnel *fresnel = BSDF_ALLOC(arena, FresnelDielectric)(e, 1.f);
float rough = roughness->Evaluate(dgs);
BxDF *spec = BSDF_ALLOC(arena, Microfacet)(ks, fresnel, BSDF_ALLOC(arena, Blinn)(1.f / rough));
bsdf->Add(spec);
}
Spectrum kr = op * Kr->Evaluate(dgs).Clamp();
if (!kr.IsBlack()) {
Fresnel *fresnel = BSDF_ALLOC(arena, FresnelDielectric)(e, 1.f);
bsdf->Add(BSDF_ALLOC(arena, SpecularReflection)(kr, fresnel));
}
Spectrum kt = op * Kt->Evaluate(dgs).Clamp();
if (!kt.IsBlack())
bsdf->Add(BSDF_ALLOC(arena, SpecularTransmission)(kt, e, 1.f));
return bsdf;
}
// Plastic Method Definitions
BSDF *plastic_dan::GetBSDF(const DifferentialGeometry &dgGeom,
const DifferentialGeometry &dgShading) const {
// Allocate _BSDF_, possibly doing bump-mapping with _bumpMap_
DifferentialGeometry dgs;
if (bumpMap)
Bump(bumpMap, dgGeom, dgShading, &dgs);
else
dgs = dgShading;
BSDF *bsdf = BSDF_ALLOC(BSDF)(dgs, dgGeom.nn);
Spectrum kd = Kd->Evaluate(dgs).Clamp();
BxDF *diff = BSDF_ALLOC(Lambertian)(kd);
Fresnel *fresnel =
BSDF_ALLOC(FresnelDielectric)(1.5f, 1.f);
Spectrum ks = Ks->Evaluate(dgs).Clamp();
float rough = roughness->Evaluate(dgs);
BxDF *spec = BSDF_ALLOC(Microfacet)(ks, fresnel,
BSDF_ALLOC(Blinn)(1.f / rough));
bsdf->Add(diff);
bsdf->Add(spec);
return bsdf;
}
void MetalMaterial::ComputeScatteringFunctions(SurfaceInteraction *si,
MemoryArena &arena,
TransportMode mode,
bool allowMultipleLobes) const {
// Perform bump mapping with _bumpMap_, if present
if (bumpMap) Bump(bumpMap, si);
si->bsdf = ARENA_ALLOC(arena, BSDF)(*si);
Float uRough =
uRoughness ? uRoughness->Evaluate(*si) : roughness->Evaluate(*si);
Float vRough =
vRoughness ? vRoughness->Evaluate(*si) : roughness->Evaluate(*si);
if (remapRoughness) {
uRough = TrowbridgeReitzDistribution::RoughnessToAlpha(uRough);
vRough = TrowbridgeReitzDistribution::RoughnessToAlpha(vRough);
}
Fresnel *frMf = ARENA_ALLOC(arena, FresnelConductor)(1., eta->Evaluate(*si),
k->Evaluate(*si));
MicrofacetDistribution *distrib =
ARENA_ALLOC(arena, TrowbridgeReitzDistribution)(uRough, vRough);
si->bsdf->Add(ARENA_ALLOC(arena, MicrofacetReflection)(1., distrib, frMf));
}
// SubsurfaceMaterial Method Definitions
BSDF *SubsurfaceMaterial::GetBSDF(const DifferentialGeometry &dgGeom,
const DifferentialGeometry &dgShading, MemoryArena &arena) const {
// Allocate _BSDF_, possibly doing bump mapping with _bumpMap_
DifferentialGeometry dgs;
// Trisha: This is a hack-y way to determine if we should use the NormalMap over the BumpMap. If the NormalMap is zero at this pixel value, we skip over it.
Spectrum normalSpectrum = normalMap->Evaluate(dgShading);
if (!normalSpectrum.IsBlack())
NormalMap(normalMap, dgGeom, dgShading, &dgs);
else if (bumpMap)
Bump(bumpMap, dgGeom, dgShading, &dgs);
else
dgs = dgShading;
BSDF *bsdf = BSDF_ALLOC(arena, BSDF)(dgs, dgGeom.nn);
Spectrum R = Kr->Evaluate(dgs).Clamp();
float e = eta->Evaluate(dgs);
if (!R.IsBlack())
bsdf->Add(BSDF_ALLOC(arena, SpecularReflection)(R,
BSDF_ALLOC(arena, FresnelDielectric)(1., e)));
return bsdf;
}
BSDF *SkinSubsurfaceMaterial::GetBSDF(const DifferentialGeometry &dgGeom,
const DifferentialGeometry &dgShading,
MemoryArena &arena) const {
DifferentialGeometry dgs;
if (bumpMap)
Bump(bumpMap, dgGeom, dgShading, &dgs);
else
dgs = dgShading;
BSDF *bsdf = BSDF_ALLOC(arena, BSDF)(dgs, dgGeom.nn);
Spectrum kd = Kd->Evaluate(dgs).Clamp();
if (!kd.IsBlack()){
BxDF *diff = BSDF_ALLOC(arena, Lambertian)(kd);
bsdf->Add(diff);
}
float e = eta->Evaluate(dgs);
Fresnel *fresnel = BSDF_ALLOC(arena,FresnelDielectric)(1.,e);
float rough = 0.35f;
BxDF *spec = BSDF_ALLOC(arena,Microfacet)(rho_s, fresnel, BSDF_ALLOC(arena, Beckmann)(rough));
bsdf->Add(spec);
return bsdf;
}
bool IMovable::CheckPassable()
{
PassableLevel loc = GetPassable(dMove);
if (loc != Passable::FULL)
{
SetPassable(dMove, Passable::FULL);
}
if (!CanPass(owner->GetPassable(dMove), passable_level))
{
owner->Bump(GetId());
force_.x = 0;
force_.y = 0;
force_.z = 0;
if (loc != Passable::FULL)
{
SetPassable(dMove, loc);
}
return false;
}
if (loc != Passable::FULL)
{
SetPassable(dMove, loc);
}
auto neighbour = owner->GetNeighbour(dMove);
if ( !CanPass(neighbour->GetPassable(D_ALL), passable_level)
|| !CanPass(neighbour->GetPassable(helpers::revert_dir(dMove)), passable_level))
{
neighbour->Bump(GetId());
force_.x = 0;
force_.y = 0;
force_.z = 0;
return false;
}
return true;
}
// TranslucentMaterial Method Definitions
void TranslucentMaterial::ComputeScatteringFunctions(
SurfaceInteraction *si, MemoryArena &arena, TransportMode mode,
bool allowMultipleLobes) const {
// Perform bump mapping with _bumpMap_, if present
if (bumpMap) Bump(bumpMap, si);
Float eta = 1.5f;
si->bsdf = ARENA_ALLOC(arena, BSDF)(*si, eta);
Spectrum r = reflect->Evaluate(*si).Clamp();
Spectrum t = transmit->Evaluate(*si).Clamp();
if (r.IsBlack() && t.IsBlack()) return;
Spectrum kd = Kd->Evaluate(*si).Clamp();
if (!kd.IsBlack()) {
if (!r.IsBlack())
si->bsdf->Add(ARENA_ALLOC(arena, LambertianReflection)(r * kd));
if (!t.IsBlack())
si->bsdf->Add(ARENA_ALLOC(arena, LambertianTransmission)(t * kd));
}
Spectrum ks = Ks->Evaluate(*si).Clamp();
if (!ks.IsBlack() && (!r.IsBlack() || !t.IsBlack())) {
Float rough = roughness->Evaluate(*si);
if (remapRoughness)
rough = TrowbridgeReitzDistribution::RoughnessToAlpha(rough);
MicrofacetDistribution *distrib =
ARENA_ALLOC(arena, TrowbridgeReitzDistribution)(rough, rough);
if (!r.IsBlack()) {
Fresnel *fresnel = ARENA_ALLOC(arena, FresnelDielectric)(1.f, eta);
si->bsdf->Add(ARENA_ALLOC(arena, MicrofacetReflection)(
r * ks, distrib, fresnel));
}
if (!t.IsBlack())
si->bsdf->Add(ARENA_ALLOC(arena, MicrofacetTransmission)(
t * ks, distrib, 1.f, eta, mode));
}
}
// GlassMaterial Method Definitions
BSDF *GlassMaterial::GetBSDF(const DifferentialGeometry &dgGeom, const DifferentialGeometry &dgShading, MemoryArena &arena) const {
DifferentialGeometry dgs;
// Trisha: This is a hack-y way to determine if we should use the NormalMap over the BumpMap. If the NormalMap is zero at this pixel value, we skip over it.
Spectrum normalSpectrum = normalMap->Evaluate(dgShading);
if (!normalSpectrum.IsBlack())
NormalMap(normalMap, dgGeom, dgShading, &dgs);
else if (bumpMap)
Bump(bumpMap, dgGeom, dgShading, &dgs);
else
dgs = dgShading;
float ior = index->Evaluate(dgs);
BSDF *bsdf = BSDF_ALLOC(arena, BSDF)(dgs, dgGeom.nn, ior);
Spectrum R = Kr->Evaluate(dgs).Clamp();
Spectrum T = Kt->Evaluate(dgs).Clamp();
if (!R.IsBlack())
bsdf->Add(BSDF_ALLOC(arena, SpecularReflection)(R,
BSDF_ALLOC(arena, FresnelDielectric)(1., ior)));
if (!T.IsBlack())
bsdf->Add(BSDF_ALLOC(arena, SpecularTransmission)(T, 1., ior));
return bsdf;
}
