/*
 * Implementation of Ward's Anisotropic Reflection
 * Author: Chia-Kai Liang
 */
/*
 * pbrt source code Copyright(c) 1998-2004 Matt Pharr and Greg Humphreys
 *
 * All Rights Reserved.
 * For educational use only; commercial use expressly forbidden.
 * NO WARRANTY, express or implied, for this software.
 * (See file License.txt for complete license)
 */

// ward.cpp*
#include <cstdio>
#include <cstdlib>
using namespace std;

#include "pbrt.h"
#include "reflection.h"
#include "material.h"
#include "color.h"
#include "mc.h"
#include "sampling.h"

// Ward BRDF Class Declarations
class Ward: public BxDF {
public:
	// FresnelBlend Public Methods
	Ward(//const Spectrum &Rd,
	             const Spectrum &Rs,
				 const float Ax,
				 const float Ay);
	Spectrum f(const Vector &wo, const Vector &wi) const;
	Spectrum f(const Vector &wo, const Vector &wi, const Vector &H) const;
	Spectrum Sample_f(const Vector &wi, Vector *sampled_f, float u1, float u2, float *pdf) const;
	float Pdf(const Vector &wi, const Vector &wo) const;
private:
	// FresnelBlend Private Data
	//Spectrum Rd, Rs;
	Spectrum Rs;
	//float dRatio, sRatio;
	float ax, ay;
	float invax2, invay2;
	float const2;
};

Ward::Ward(//const Spectrum &d,
	             const Spectrum &s,
				 const float Ax,
				 const float Ay)
	: BxDF(BxDFType(BSDF_REFLECTION | BSDF_GLOSSY)),
		Rs(s){
		//Rd(d), Rs(s){
	ax = Ax;
	ay = Ay;
	invax2 = 1.f/(ax*ax);
	invay2 = 1.f/(ay*ay);
	const2 = (4*M_PI*ax*ay);
	//float invSum = 1.f/(Rd.y()+Rs.y());
	//dRatio = Rd.y()*invSum;
	//sRatio = Rs.y()*invSum;
}

Spectrum Ward::f(const Vector &wo, const Vector &wi) const{
	Spectrum specular(0.f);
	
	//Vector H = Normalize(wi + wo);
	Vector H = wi + wo;
	if(H.z <= 0.f) return specular;
	float const1 = wi.z*wo.z;
	if(const1 <= 0.f) return specular;
	const1 = sqrtf(const1);
	float const3 = exp(-1.f * (H.x*H.x*invax2 + H.y*H.y*invay2)/(H.z*H.z) );
	specular = Rs * const3/(const1*const2); 
	return specular;
	//Spectrum diffuse = Rd*INV_PI;
	//return diffuse + specular;
}

Spectrum Ward::f(const Vector &wo, const Vector &wi, const Vector &H) const{
	Spectrum specular(0.f);
	
	if(H.z <= 0.f) return specular;
	float const1 = wi.z*wo.z;
	if(const1 <= 0.f) return specular;
	const1 = sqrtf(const1);
	float const3 = exp(-1.f * (H.x*H.x*invax2 + H.y*H.y*invay2)/(H.z*H.z) );
	specular = Rs * const3/(const1*const2); 
	return specular;	
}

Spectrum Ward::Sample_f(const Vector &wo,
		Vector *wi, float u1, float u2, float *pdf) const {
	Vector h;
	float phi = atanf(ay*tan(2*M_PI*u2)/ax);
	float cosPhi = cosf(phi);
	float sinPhi = sqrtf(1-cosPhi*cosPhi);
	float theta = atanf(sqrtf(-logf(u1)/(cosPhi*cosPhi*invax2 + sinPhi*sinPhi*invay2)));
	
	h.z = cosf(theta);
	float cosTheta2 = h.z*h.z;
	float sinTheta = sqrtf(1-cosTheta2);
	float tanTheta2 = (1-cosTheta2)/cosTheta2;
	h.x = cosPhi*sinTheta;
	h.y = sinPhi*sinTheta;
	if(Dot(wo, h) < 0.f) h = -h;
	*wi = -wo + 2.f * Dot(wo, h) * h;
	// swith the comments of the following two lines if you want to see the effect of using wrong pdf
	//*pdf = BxDF::Pdf(wo, *wi);
	*pdf = expf(-tanTheta2*(cosPhi*cosPhi*invax2 + sinPhi*sinPhi*invay2))/(const2*Dot(h,*wo)*cosTheta2*h.z);
	return f(wo, wi, h);

oldcode:
	// Cosine-sample the hemisphere, flipping the direction if necessary
	*wi = CosineSampleHemisphere(u1, u2);
	if (wo.z < 0.) wi->z *= -1.f;
	*pdf = BxDF::Pdf(wo, *wi);
	return f(wo, *wi);
}

float Ward::Pdf(const Vector &wi, const Vector &wo) const{
	Vector h = Normalize(wi+wo);
	float cosTheta2 = h.z*h.z;
	float tanTheta2 = (1-cosTheta2)/cosTheta2;
	float cosPhi = CosPhi(h);
	float sinPhi = SinPhi(h);

	return expf(-tanTheta2*(cosPhi*cosPhi*invax2 + sinPhi*sinPhi*invay2))/(const2*Dot(h,wo)*cosTheta2*h.z);
}

// Ward Material Class Declarations
class WardMaterial : public Material {
public:
	// Substrate Public Methods
	WardMaterial(Reference<Texture<Spectrum> > kd, Reference<Texture<Spectrum> > ks,
			Reference<Texture<float> > alphaX, Reference<Texture<float> > alphaY,
			Reference<Texture<float> > bump) {
		Kd = kd;
		Ks = ks;
		nax = alphaX;
		nay = alphaY; 
		bumpMap = bump;
	}
	BSDF *GetBSDF(const DifferentialGeometry &dgGeom, const DifferentialGeometry &dgShading) const;
private:
	// Substrate Private Data
	Reference<Texture<Spectrum> > Kd, Ks;
	Reference<Texture<float> > nax, nay;
	Reference<Texture<float> > bumpMap;
};
// Substrate Method Definitions
BSDF *WardMaterial::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 ax = nax->Evaluate(dgs);
	float ay = nay->Evaluate(dgs);
	
	bsdf->Add(BSDF_ALLOC(Ward)(s, ax, ay));
	bsdf->Add(BSDF_ALLOC(Lambertian)(d));
	return bsdf;
}
extern "C" DLLEXPORT Material * CreateMaterial(const Transform &xform,
		const TextureParams &mp) {
	Reference<Texture<Spectrum> > Kd = mp.GetSpectrumTexture("Kd", Spectrum(.5f));
	Reference<Texture<Spectrum> > Ks = mp.GetSpectrumTexture("Ks", Spectrum(.5f));
	Reference<Texture<float> > alphaX = mp.GetFloatTexture("ax", .1f);
	Reference<Texture<float> > alphaY = mp.GetFloatTexture("ay", .1f);
	Reference<Texture<float> > bumpMap = mp.GetFloatTexture("bumpmap", 0.f);
	return new WardMaterial(Kd, Ks, alphaX, alphaY, bumpMap);
}
ap);
}
