/*
This file is part of Mitsuba, a physically based rendering system.
Copyright (c) 2007-2011 by Wenzel Jakob and others.
Mitsuba is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License Version 3
as published by the Free Software Foundation.
Mitsuba is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <mitsuba/core/fresolver.h>
#include <mitsuba/render/bsdf.h>
#include <mitsuba/render/sampler.h>
#include <mitsuba/hw/basicshader.h>
#include "microfacet.h"
MTS_NAMESPACE_BEGIN
/*!\plugin{roughconductor}{Rough conductor material}
* \order{6}
* \parameters{
* \parameter{distribution}{\String}{
* Specifies the type of microfacet normal distribution
* used to model the surface roughness.
* \begin{enumerate}[(i)]
* \item \code{beckmann}: Physically-based distribution derived from
* Gaussian random surfaces. This is the default.
* \item \code{ggx}: New distribution proposed by
* Walter et al. \cite{Walter07Microfacet}, which is meant to better handle
* the long tails observed in measurements of ground surfaces.
* \item \code{phong}: Classical $\cos^p\theta$ distribution.
* Due to the underlying microfacet theory,
* the use of this distribution here leads to more realistic
* behavior than the separately available \pluginref{phong} plugin.
* \item \code{as}: Anisotropic Phong-style microfacet distribution proposed by
* Ashikhmin and Shirley \cite{Ashikhmin2005Anisotropic}.\vspace{-3mm}
* \end{enumerate}
* }
* \parameter{alpha}{\Float\Or\Texture}{
* Specifies the roughness of the unresolved surface microgeometry.
* When the Beckmann distribution is used, this parameter is equal to the
* \emph{root mean square} (RMS) slope of the microfacets. This
* parameter is only valid when \texttt{distribution=beckmann/phong/ggx}.
* \default{0.1}.
* }
* \parameter{alphaU, alphaV}{\Float\Or\Texture}{
* Specifies the anisotropic roughness values along the tangent and
* bitangent directions. These parameter are only valid when
* \texttt{distribution=as}. \default{0.1}.
* }
* \parameter{material}{\String}{Name of a material preset, see
* \tblref{conductor-iors}.\!\default{\texttt{Cu} / copper}}
* \parameter{eta}{\Spectrum}{Real part of the material's index
* of refraction \default{based on the value of \texttt{material}}}
* \parameter{k}{\Spectrum}{Imaginary part of the material's index of
* refraction, also known as absorption coefficient.
* \default{based on the value of \texttt{material}}}
* \parameter{specular\showbreak Reflectance}{\Spectrum\Or\Texture}{Optional
* factor used to modulate the reflectance component\default{1.0}}
* }
* This plugin implements a realistic microfacet scattering model for rendering
* rough conducting materials, such as metals. Microfacet theory describes rough
* surfaces as an arrangement of unresolved and ideally specular facets, whose
* normal directions are given by a specially chosen \emph{microfacet distribution}.
* By accounting for shadowing and masking effects between these facets, it is
* possible to reproduce the important off-specular reflections peaks observed
* in real-world measurements of such materials.
* \renderings{
* \rendering{Rough copper (Beckmann, $\alpha=0.1$)}
* {bsdf_roughconductor_copper.jpg}
* \rendering{Vertically brushed aluminium (Ashikhmin-Shirley,
* $\alpha_u=0.05,\ \alpha_v=0.3$), see
* \lstref{roughconductor-aluminium}}
* {bsdf_roughconductor_anisotropic_aluminium.jpg}
* \vspace{-7mm}
* }
*
* This plugin is essentially the ``roughened'' equivalent of the (smooth) plugin
* \pluginref{conductor}. For very low values of $\alpha$, the two will
* be very similar, though scenes using this plugin will take longer to render
* due to the additional computational burden of tracking surface roughness.
*
* The implementation is based on the paper ``Microfacet Models
* for Refraction through Rough Surfaces'' by Walter et al.
* \cite{Walter07Microfacet}. It supports several different types of microfacet
* distributions and has a texturable roughness parameter.
* To faciliate the tedious task of specifying spectrally-varying index of
* refraction information, this plugin can access a set of measured materials
* for which visible-spectrum information was publicly available
* (see \tblref{conductor-iors} for the full list).
*
* When no parameters are given, the plugin activates the default settings,
* which describe copper with a light amount of roughness modeled using a
* Beckmann distribution.
*
* To get an intuition about the effect of the surface roughness
* parameter $\alpha$, consider the following approximate differentiation:
* a value of $\alpha=0.001-0.01$ corresponds to a material
* with slight imperfections on an
* otherwise smooth surface finish, $\alpha=0.1$ is relatively rough,
* and $\alpha=0.3-0.7$ is \emph{extremely} rough (e.g. an etched or ground
* finish).
* \vspace{-2mm}
* \subsubsection*{Techical details}\vspace{-2mm}
* When rendering with the Ashikhmin-Shirley or Phong microfacet
* distributions, a conversion is used to turn the specified
* $\alpha$ roughness value into the exponents of these distributions.
* This is done in a way, such that the different
* distributions all produce a similar appearance for the same value of
* $\alpha$.
*
* The Ashikhmin-Shirley microfacet distribution allows the specification
* of two distinct roughness values along the tangent and bitangent
* directions. This can be used to provide a material with a ``brushed''
* appearance. The alignment of the anisotropy will follow the UV
* parameterization of the underlying mesh in this case. This means that
* such an anisotropic material cannot be applied to triangle meshes that
* are missing texture coordinates.
*
* When using this plugin, you should ideally compile Mitsuba with support for
* spectral rendering to get the most accurate results. While it also works
* in RGB mode, the computations will be much more approximate in this case.
* Also note that this material is one-sided---that is, observed from the
* back side, it will be completely black. If this is undesirable,
* consider using the \pluginref{twosided} BRDF adapter plugin.
*
* \begin{xml}[caption={A material definition for brushed aluminium}, label=lst:roughconductor-aluminium]
* <bsdf type="roughconductor">
* <string name="material" value="Cu"/>
* <string name="distribution" value="as"/>
* <float name="alphaU" value="0.05"/>
* <float name="alphaV" value="0.3"/>
* </bsdf>
* \end{xml}
*
*/
class RoughConductor : public BSDF {
public:
RoughConductor(const Properties &props) : BSDF(props) {
ref<FileResolver> fResolver = Thread::getThread()->getFileResolver();
m_specularReflectance = new ConstantSpectrumTexture(
props.getSpectrum("specularReflectance", Spectrum(1.0f)));
std::string material = props.getString("material", "Cu");
Spectrum materialEta, materialK;
materialEta.fromContinuousSpectrum(InterpolatedSpectrum(
fResolver->resolve("data/ior/" + material + ".eta.spd")));
materialK.fromContinuousSpectrum(InterpolatedSpectrum(
fResolver->resolve("data/ior/" + material + ".k.spd")));
m_eta = props.getSpectrum("eta", materialEta);
m_k = props.getSpectrum("k", materialK);
m_distribution = MicrofacetDistribution(
props.getString("distribution", "beckmann")
);
Float alpha = props.getFloat("alpha", 0.1f),
alphaU = props.getFloat("alphaU", alpha),
alphaV = props.getFloat("alphaV", alpha);
m_alphaU = new ConstantFloatTexture(alphaU);
if (alphaU == alphaV)
m_alphaV = m_alphaU;
else
m_alphaV = new ConstantFloatTexture(alphaV);
m_usesRayDifferentials = false;
}
RoughConductor(Stream *stream, InstanceManager *manager)
: BSDF(stream, manager) {
m_distribution = MicrofacetDistribution(
(MicrofacetDistribution::EType) stream->readUInt()
);
m_alphaU = static_cast<Texture *>(manager->getInstance(stream));
m_alphaV = static_cast<Texture *>(manager->getInstance(stream));
m_specularReflectance = static_cast<Texture *>(manager->getInstance(stream));
m_eta = Spectrum(stream);
m_k = Spectrum(stream);
m_usesRayDifferentials =
m_alphaU->usesRayDifferentials() ||
m_alphaV->usesRayDifferentials() ||
m_specularReflectance->usesRayDifferentials();
configure();
}
void configure() {
unsigned int extraFlags = 0;
if (m_alphaU != m_alphaV) {
extraFlags |= EAnisotropic;
if (m_distribution.getType() !=
MicrofacetDistribution::EAshikhminShirley)
Log(EError, "Different roughness values along the tangent and "
"bitangent directions are only supported when using the "
"anisotropic Ashikhmin-Shirley microfacet distribution "
"(named \"as\")");
}
m_components.clear();
m_components.push_back(
EGlossyReflection | EFrontSide | extraFlags);
/* Verify the input parameters and fix them if necessary */
m_specularReflectance = ensureEnergyConservation(
m_specularReflectance, "specularReflectance", 1.0f);
BSDF::configure();
}
virtual ~RoughConductor() { }
/// Helper function: reflect \c wi with respect to a given surface normal
inline Vector reflect(const Vector &wi, const Normal &m) const {
return 2 * dot(wi, m) * Vector(m) - wi;
}
Spectrum eval(const BSDFQueryRecord &bRec, EMeasure measure) const {
/* Stop if this component was not requested */
if (measure != ESolidAngle ||
Frame::cosTheta(bRec.wi) < 0 ||
Frame::cosTheta(bRec.wo) < 0 ||
((bRec.component != -1 && bRec.component != 0) ||
!(bRec.typeMask & EGlossyReflection)))
return Spectrum(0.0f);
/* Calculate the reflection half-vector */
Vector H = normalize(bRec.wo+bRec.wi);
/* Evaluate the roughness */
Float alphaU = m_distribution.transformRoughness(
m_alphaU->getValue(bRec.its).average()),
alphaV = m_distribution.transformRoughness(
m_alphaV->getValue(bRec.its).average());
/* Evaluate the microsurface normal distribution */
const Float D = m_distribution.eval(H, alphaU, alphaV);
if (D == 0)
return Spectrum(0.0f);
/* Fresnel factor */
const Spectrum F = fresnelConductor(Frame::cosTheta(bRec.wi), m_eta, m_k);
/* Smith's shadow-masking function */
const Float G = m_distribution.G(bRec.wi, bRec.wo, H, alphaU, alphaV);
/* Calculate the total amount of reflection */
Float value = D * G / (4.0f * Frame::cosTheta(bRec.wi));
return m_specularReflectance->getValue(bRec.its) * F * value;
}
Float pdf(const BSDFQueryRecord &bRec, EMeasure measure) const {
if (measure != ESolidAngle ||
Frame::cosTheta(bRec.wi) < 0 ||
Frame::cosTheta(bRec.wo) < 0 ||
((bRec.component != -1 && bRec.component != 0) ||
!(bRec.typeMask & EGlossyReflection)))
return 0.0f;
/* Calculate the reflection half-vector */
Vector H = normalize(bRec.wo+bRec.wi);
/* Evaluate the roughness */
Float alphaU = m_distribution.transformRoughness(
m_alphaU->getValue(bRec.its).average()),
alphaV = m_distribution.transformRoughness(
m_alphaV->getValue(bRec.its).average());
return m_distribution.pdf(H, alphaU, alphaV)
/ (4 * absDot(bRec.wo, H));
}
Spectrum sample(BSDFQueryRecord &bRec, const Point2 &sample) const {
if (Frame::cosTheta(bRec.wi) < 0 ||
((bRec.component != -1 && bRec.component != 0) ||
!(bRec.typeMask & EGlossyReflection)))
return Spectrum(0.0f);
/* Evaluate the roughness */
Float alphaU = m_distribution.transformRoughness(
m_alphaU->getValue(bRec.its).average()),
alphaV = m_distribution.transformRoughness(
m_alphaV->getValue(bRec.its).average());
/* Sample M, the microsurface normal */
const Normal m = m_distribution.sample(sample, alphaU, alphaV);
/* Perfect specular reflection based on the microsurface normal */
bRec.wo = reflect(bRec.wi, m);
bRec.sampledComponent = 0;
bRec.sampledType = EGlossyReflection;
/* Side check */
if (Frame::cosTheta(bRec.wo) <= 0)
return Spectrum(0.0f);
const Spectrum F = fresnelConductor(Frame::cosTheta(bRec.wi),
m_eta, m_k);
Float numerator = m_distribution.G(bRec.wi, bRec.wo, m, alphaU, alphaV)
* dot(bRec.wi, m);
Float denominator = Frame::cosTheta(m)
* Frame::cosTheta(bRec.wi);
return m_specularReflectance->getValue(bRec.its) * F
* (numerator / denominator);
}
Spectrum sample(BSDFQueryRecord &bRec, Float &_pdf, const Point2 &sample) const {
if (Frame::cosTheta(bRec.wi) < 0 ||
((bRec.component != -1 && bRec.component != 0) ||
!(bRec.typeMask & EGlossyReflection)))
return Spectrum(0.0f);
/* Evaluate the roughness */
Float alphaU = m_distribution.transformRoughness(
m_alphaU->getValue(bRec.its).average()),
alphaV = m_distribution.transformRoughness(
m_alphaV->getValue(bRec.its).average());
/* Sample M, the microsurface normal */
const Normal m = m_distribution.sample(sample, alphaU, alphaV);
/* Perfect specular reflection based on the microsurface normal */
bRec.wo = reflect(bRec.wi, m);
bRec.sampledComponent = 0;
bRec.sampledType = EGlossyReflection;
/* Side check */
if (Frame::cosTheta(bRec.wo) <= 0)
return Spectrum(0.0f);
/* Guard against numerical imprecisions */
_pdf = pdf(bRec, ESolidAngle);
if (_pdf == 0)
return Spectrum(0.0f);
else
return eval(bRec, ESolidAngle);
}
void addChild(const std::string &name, ConfigurableObject *child) {
if (child->getClass()->derivesFrom(MTS_CLASS(Texture)) && name == "alpha") {
m_alphaU = m_alphaV = static_cast<Texture *>(child);
m_usesRayDifferentials |= m_alphaU->usesRayDifferentials();
} else if (child->getClass()->derivesFrom(MTS_CLASS(Texture)) && name == "alphaU") {
m_alphaU = static_cast<Texture *>(child);
m_usesRayDifferentials |= m_alphaU->usesRayDifferentials();
} else if (child->getClass()->derivesFrom(MTS_CLASS(Texture)) && name == "alphaV") {
m_alphaV = static_cast<Texture *>(child);
m_usesRayDifferentials |= m_alphaV->usesRayDifferentials();
} else if (child->getClass()->derivesFrom(MTS_CLASS(Texture)) && name == "specularReflectance") {
m_specularReflectance = static_cast<Texture *>(child);
m_usesRayDifferentials |= m_specularReflectance->usesRayDifferentials();
} else {
BSDF::addChild(name, child);
}
}
void serialize(Stream *stream, InstanceManager *manager) const {
BSDF::serialize(stream, manager);
stream->writeUInt((uint32_t) m_distribution.getType());
manager->serialize(stream, m_alphaU.get());
manager->serialize(stream, m_alphaV.get());
manager->serialize(stream, m_specularReflectance.get());
m_eta.serialize(stream);
m_k.serialize(stream);
}
std::string toString() const {
std::ostringstream oss;
oss << "RoughConductor[" << endl
<< " name = \"" << getName() << "\"," << endl
<< " distribution = " << m_distribution.toString() << "," << endl
<< " alphaU = " << indent(m_alphaU->toString()) << "," << endl
<< " alphaV = " << indent(m_alphaV->toString()) << "," << endl
<< " specularReflectance = " << indent(m_specularReflectance->toString()) << "," << endl
<< " eta = " << m_eta.toString() << "," << endl
<< " k = " << m_k.toString() << endl
<< "]";
return oss.str();
}
Shader *createShader(Renderer *renderer) const;
MTS_DECLARE_CLASS()
private:
MicrofacetDistribution m_distribution;
ref<Texture> m_specularReflectance;
ref<Texture> m_alphaU, m_alphaV;
Spectrum m_eta, m_k;
};
/**
* GLSL port of the rough conductor shader. This version is much more
* approximate -- it only supports the Ashikhmin-Shirley distribution,
* does everything in RGB, and it uses the Schlick approximation to the
* Fresnel reflectance of conductors. When the roughness is lower than
* \alpha < 0.2, the shader clamps it to 0.2 so that it will still perform
* reasonably well in a VPL-based preview.
*/
class RoughConductorShader : public Shader {
public:
RoughConductorShader(Renderer *renderer, const Texture *specularReflectance,
const Texture *alphaU, const Texture *alphaV, const Spectrum &eta,
const Spectrum &k) : Shader(renderer, EBSDFShader),
m_specularReflectance(specularReflectance), m_alphaU(alphaU), m_alphaV(alphaV){
m_specularReflectanceShader = renderer->registerShaderForResource(m_specularReflectance.get());
m_alphaUShader = renderer->registerShaderForResource(m_alphaU.get());
m_alphaVShader = renderer->registerShaderForResource(m_alphaV.get());
/* Compute the reflectance at perpendicular incidence */
m_R0 = fresnelConductor(1.0f, eta, k);
}
bool isComplete() const {
return m_specularReflectanceShader.get() != NULL &&
m_alphaUShader.get() != NULL &&
m_alphaVShader.get() != NULL;
}
void putDependencies(std::vector<Shader *> &deps) {
deps.push_back(m_specularReflectanceShader.get());
deps.push_back(m_alphaUShader.get());
deps.push_back(m_alphaVShader.get());
}
void cleanup(Renderer *renderer) {
renderer->unregisterShaderForResource(m_specularReflectance.get());
renderer->unregisterShaderForResource(m_alphaU.get());
renderer->unregisterShaderForResource(m_alphaV.get());
}
void resolve(const GPUProgram *program, const std::string &evalName, std::vector<int> ¶meterIDs) const {
parameterIDs.push_back(program->getParameterID(evalName + "_R0", false));
}
void bind(GPUProgram *program, const std::vector<int> ¶meterIDs, int &textureUnitOffset) const {
program->setParameter(parameterIDs[0], m_R0);
}
void generateCode(std::ostringstream &oss,
const std::string &evalName,
const std::vector<std::string> &depNames) const {
oss << "uniform vec3 " << evalName << "_R0;" << endl
<< endl
<< "float " << evalName << "_D(vec3 m, float alphaU, float alphaV) {" << endl
<< " float ct = cosTheta(m), ds = 1-ct*ct;" << endl
<< " if (ds <= 0.0)" << endl
<< " return 0.0f;" << endl
<< " alphaU = 2 / (alphaU * alphaU) - 2;" << endl
<< " alphaV = 2 / (alphaV * alphaV) - 2;" << endl
<< " float exponent = (alphaU*m.x*m.x + alphaV*m.y*m.y)/ds;" << endl
<< " return sqrt((alphaU+2) * (alphaV+2)) * 0.15915 * pow(ct, exponent);" << endl
<< "}" << endl
<< endl
<< "float " << evalName << "_G(vec3 m, vec3 wi, vec3 wo) {" << endl
<< " if ((dot(wi, m) * cosTheta(wi)) <= 0 || " << endl
<< " (dot(wo, m) * cosTheta(wo)) <= 0)" << endl
<< " return 0.0;" << endl
<< " float nDotM = cosTheta(m);" << endl
<< " return min(1.0, min(" << endl
<< " abs(2 * nDotM * cosTheta(wo) / dot(wo, m))," << endl
<< " abs(2 * nDotM * cosTheta(wi) / dot(wi, m))));" << endl
<< "}" << endl
<< endl
<< "vec3 " << evalName << "_schlick(vec3 wi) {" << endl
<< " float ct = cosTheta(wi), ctSqr = ct*ct," << endl
<< " ct5 = ctSqr*ctSqr*ct;" << endl
<< " return " << evalName << "_R0 + (vec3(1.0) - " << evalName << "_R0) * ct5;" << endl
<< "}" << endl
<< endl
<< "vec3 " << evalName << "(vec2 uv, vec3 wi, vec3 wo) {" << endl
<< " if (cosTheta(wi) <= 0 || cosTheta(wo) <= 0)" << endl
<< " return vec3(0.0);" << endl
<< " vec3 H = normalize(wi + wo);" << endl
<< " vec3 reflectance = " << depNames[0] << "(uv);" << endl
<< " float alphaU = max(0.2, " << depNames[1] << "(uv).r);" << endl
<< " float alphaV = max(0.2, " << depNames[2] << "(uv).r);" << endl
<< " float D = " << evalName << "_D(H, alphaU, alphaV)" << ";" << endl
<< " float G = " << evalName << "_G(H, wi, wo);" << endl
<< " vec3 Fr = " << evalName << "_schlick(wi);" << endl
<< " return reflectance * Fr * (D * G / (4*cosTheta(wi)));" << endl
<< "}" << endl
<< endl
<< "vec3 " << evalName << "_diffuse(vec2 uv, vec3 wi, vec3 wo) {" << endl
<< " return " << evalName << "_R0 * 0.31831 * cosTheta(wo);"<< endl
<< "}" << endl;
}
MTS_DECLARE_CLASS()
private:
ref<const Texture> m_specularReflectance;
ref<const Texture> m_alphaU;
ref<const Texture> m_alphaV;
ref<Shader> m_specularReflectanceShader;
ref<Shader> m_alphaUShader;
ref<Shader> m_alphaVShader;
Spectrum m_R0;
};
Shader *RoughConductor::createShader(Renderer *renderer) const {
return new RoughConductorShader(renderer,
m_specularReflectance.get(), m_alphaU.get(), m_alphaV.get(), m_eta, m_k);
}
MTS_IMPLEMENT_CLASS(RoughConductorShader, false, Shader)
MTS_IMPLEMENT_CLASS_S(RoughConductor, false, BSDF)
MTS_EXPORT_PLUGIN(RoughConductor, "Rough conductor BRDF");
MTS_NAMESPACE_END