1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
/******************************************************************/
/* This file is part of the homework assignments for CSCI-427/527 */
/* at The College of William & Mary and authored by Pieter Peers. */
/* No part of this file, whether altered or in original form, can */
/* be distributed or used outside the context of CSCI-427/527 */
/* without consent of either the College of William & Mary or */
/* Pieter Peers. */
/******************************************************************/
#include <cmath>
#include "constants.h"
#include "phongBrdf.h"
#include "coordinateTransform.h"
//////////////////
// Constructors //
//////////////////
phongBrdf::phongBrdf(const color& albedo, float sharpness)
{
_albedo = albedo;
_sharpness = sharpness;
}
phongBrdf::phongBrdf(const phongBrdf& src)
{
_albedo = src._albedo;
_sharpness = src._sharpness;
}
///////////////
// Operators //
///////////////
phongBrdf& phongBrdf::operator=(const phongBrdf& src)
{
_assign(src);
return *this;
}
/////////////
// Methods //
/////////////
color phongBrdf::shade(const vec3d& in, const vec3d& out) const
{
// sanity check (below horizon)
if(in.z < 0.0f || out.z < 0.0f) return color(0.0f);
// compute reflected direction (simplies when n=(0,0,1))
vec3d reflected(-in.x, -in.y, in.z);
// evaluate phong
return _albedo * std::pow(std::max( reflected.dot(out), 0.0f), _sharpness);
}
color phongBrdf::reflectance(const vec3d& in, const vec3d& out) const
{
// use shade evaluation times a normalization factor to ensure
// conservation of enegery.
return shade(in, out) * (_sharpness + 2.0f) / (2.0f * PI);
}
brdfSample phongBrdf::sample(const vec3d& in, float r1, float r2) const
{
// sanity check
if(in.z < 0.0f) return brdfSample();
// compute reflected direction
vec3d reflected(-in.x, -in.y, in.z);
// sample hemisphere around reflected direction.
vec3d out( sqrt( 1.0f - pow(r1, 2.0f / (_sharpness + 1.0f)) ) * cos(2.0f * PI * r2),
sqrt( 1.0f - pow(r1, 2.0f / (_sharpness + 1.0f)) ) * sin(2.0f * PI * r2),
pow(r1, 1.0f / (_sharpness + 1.0f)) );
// transform to global coord
coordinateTransformation trans(reflected);
out = trans.transformDirection(out);
// compute pdf
float pdf = 0.0f;
if(out.z >= 0.0f)
pdf = (_sharpness + 1.0f) / (2.0f * PI) * pow(reflected.dot(out), _sharpness);
// Done.
return brdfSample(out, pdf, this->reflectance(in, out));
}
bool phongBrdf::isSpecular(void) const
{
// Consider low roughness to be diffuse.
// Use 5.0f as an arbitrary threshold.
return (_sharpness > 5.0f);
}
bool phongBrdf::isDiffuse(void) const
{
return !isSpecular();
}
float phongBrdf::reflectivity(void) const
{
// Done.
return (_albedo.r + _albedo.g + _albedo.b) / 3.0f;
}
/////////////////////
// Private Methods //
/////////////////////
void phongBrdf::_assign(const phongBrdf& src)
{
_albedo = src._albedo;
_sharpness = src._sharpness;
}
void phongBrdf::_swap(phongBrdf& src)
{
swap(_albedo, src._albedo);
std::swap(_sharpness, src._sharpness);
}
void phongBrdf::_print(std::ostream& s) const
{
s << "Phong BRDF: albedo=" << _albedo << ", sharpness=" << _sharpness;
}
|
