public void prepareShadingState(ShadingState state)
{
state.init();
state.getRay().getPoint(state.getPoint());
Instance parent = state.getInstance();
// get local point
Point3 p = parent.transformWorldToObject(state.getPoint());
// compute local normal
float deriv = p.x * p.x + p.y * p.y + p.z * p.z - ri2 - ro2;
state.getNormal().set(p.x * deriv, p.y * deriv, p.z * deriv + 2 * ro2 * p.z);
state.getNormal().normalize();
double phi = Math.Asin(MathUtils.clamp(p.z / ri, -1, 1));
double theta = Math.Atan2(p.y, p.x);
if (theta < 0)
{
theta += 2 * Math.PI;
}
state.getUV().x = (float)(theta / (2 * Math.PI));
state.getUV().y = (float)((phi + Math.PI / 2) / Math.PI);
state.setShader(parent.getShader(0));
state.setModifier(parent.getModifier(0));
// into world space
Vector3 worldNormal = parent.transformNormalObjectToWorld(state.getNormal());
state.getNormal().set(worldNormal);
state.getNormal().normalize();
state.getGeoNormal().set(state.getNormal());
// make basis in world space
state.setBasis(OrthoNormalBasis.makeFromW(state.getNormal()));
}
public Color getIrradiance(ShadingState state, Color diffuseReflectance)
{
if (samples <= 0)
return Color.BLACK;
// compute new sample
Color irr = Color.black();
OrthoNormalBasis onb = state.getBasis();
Vector3 w = new Vector3();
int n = state.getDiffuseDepth() == 0 ? samples : 1;
for (int i = 0; i < n; i++)
{
float xi = (float)state.getRandom(i, 0, n);
float xj = (float)state.getRandom(i, 1, n);
float phi = (float)(xi * 2 * Math.PI);
float cosPhi = (float)Math.Cos(phi);
float sinPhi = (float)Math.Sin(phi);
float sinTheta = (float)Math.Sqrt(xj);
float cosTheta = (float)Math.Sqrt(1.0f - xj);
w.x = cosPhi * sinTheta;
w.y = sinPhi * sinTheta;
w.z = cosTheta;
onb.transform(w);
ShadingState temp = state.traceFinalGather(new Ray(state.getPoint(), w), i);
if (temp != null)
{
temp.getInstance().prepareShadingState(temp);
if (temp.getShader() != null)
irr.add(temp.getShader().getRadiance(temp));
}
}
irr.mul((float)Math.PI / n);
return irr;
}
public void prepareShadingState(ShadingState state)
{
state.init();
state.getRay().getPoint(state.getPoint());
Instance parent = state.getInstance();
Point3 localPoint = state.transformWorldToObject(state.getPoint());
state.getNormal().set(localPoint.x, localPoint.y, 0);
state.getNormal().normalize();
float phi = (float)Math.Atan2(state.getNormal().y, state.getNormal().x);
if (phi < 0)
{
phi += (float)(2.0 * Math.PI);
}
state.getUV().x = phi / (float)(2 * Math.PI);
state.getUV().y = (localPoint.z + 1) * 0.5f;
state.setShader(parent.getShader(0));
state.setModifier(parent.getModifier(0));
// into world space
Vector3 worldNormal = state.transformNormalObjectToWorld(state.getNormal());
Vector3 v = state.transformVectorObjectToWorld(new Vector3(0, 0, 1));
state.getNormal().set(worldNormal);
state.getNormal().normalize();
state.getGeoNormal().set(state.getNormal());
// compute basis in world space
state.setBasis(OrthoNormalBasis.makeFromWV(state.getNormal(), v));
}
public void prepareShadingState(ShadingState state)
{
state.init();
state.getRay().getPoint(state.getPoint());
Instance parent = state.getInstance();
Point3 localPoint = parent.transformWorldToObject(state.getPoint());
state.getNormal().set(localPoint.x, localPoint.y, localPoint.z);
state.getNormal().normalize();
float phi = (float)Math.Atan2(state.getNormal().y, state.getNormal().x);
if (phi < 0)
phi += (float)(2 * Math.PI);
float theta = (float)Math.Acos(state.getNormal().z);
state.getUV().y = theta / (float)Math.PI;
state.getUV().x = phi / (float)(2 * Math.PI);
Vector3 v = new Vector3();
v.x = -2 * (float)Math.PI * state.getNormal().y;
v.y = 2 * (float)Math.PI * state.getNormal().x;
v.z = 0;
state.setShader(parent.getShader(0));
state.setModifier(parent.getModifier(0));
// into world space
Vector3 worldNormal = parent.transformNormalObjectToWorld(state.getNormal());
v = parent.transformVectorObjectToWorld(v);
state.getNormal().set(worldNormal);
state.getNormal().normalize();
state.getGeoNormal().set(state.getNormal());
// compute basis in world space
state.setBasis(OrthoNormalBasis.makeFromWV(state.getNormal(), v));
}
public Color getRadiance(ShadingState state)
{
// don't use these - gather lights for sphere of directions
// gather lights
state.initLightSamples();
state.initCausticSamples();
Vector3 v = state.getRay().getDirection();
v.negate();
Vector3 h = new Vector3();
Vector3 t = state.getBasis().transform(new Vector3(0, 1, 0));
Color diff = Color.black();
Color spec = Color.black();
foreach (LightSample ls in state)
{
Vector3 l = ls.getShadowRay().getDirection();
float dotTL = Vector3.dot(t, l);
float sinTL = (float)Math.Sqrt(1 - dotTL * dotTL);
// float dotVL = Vector3.dot(v, l);
diff.madd(sinTL, ls.getDiffuseRadiance());
Vector3.add(v, l, h);
h.normalize();
float dotTH = Vector3.dot(t, h);
float sinTH = (float)Math.Sqrt(1 - dotTH * dotTH);
float s = (float)Math.Pow(sinTH, 10.0f);
spec.madd(s, ls.getSpecularRadiance());
}
Color c = Color.add(diff, spec, new Color());
// transparency
return Color.blend(c, state.traceTransparency(), state.getV(), new Color());
}
public void prepareShadingState(ShadingState state)
{
if (state.includeLights)
{
state.setShader(this);
}
}
public Color GetRadiance(ShadingState state)
{
if (!state.includeSpecular)
{
return(Color.BLACK);
}
state.faceforward();
float cos = state.getCosND();
float dn = 2 * cos;
Vector3 refDir = new Vector3();
refDir.x = (dn * state.getNormal().x) + state.getRay().getDirection().x;
refDir.y = (dn * state.getNormal().y) + state.getRay().getDirection().y;
refDir.z = (dn * state.getNormal().z) + state.getRay().getDirection().z;
Ray refRay = new Ray(state.getPoint(), refDir);
// compute Fresnel term
cos = 1 - cos;
float cos2 = cos * cos;
float cos5 = cos2 * cos2 * cos;
Color ret = Color.white();
ret.sub(color);
ret.mul(cos5);
ret.add(color);
return(ret.mul(state.traceReflection(refRay, 0)));
}
public void scatterPhoton(ShadingState state, Color power)
{
Color diffuse;
// make sure we are on the right side of the material
if (Vector3.dot(state.getNormal(), state.getRay().getDirection()) > 0.0)
{
state.getNormal().negate();
state.getGeoNormal().negate();
}
diffuse = getDiffuse(state);
state.storePhoton(state.getRay().getDirection(), power, diffuse);
float avg = diffuse.getAverage();
double rnd = state.getRandom(0, 0, 1);
if (rnd < avg)
{
// photon is scattered
power.mul(diffuse).mul(1.0f / avg);
OrthoNormalBasis onb = state.getBasis();
double u = 2 * Math.PI * rnd / avg;
double v = state.getRandom(0, 1, 1);
float s = (float)Math.Sqrt(v);
float s1 = (float)Math.Sqrt(1.0 - v);
Vector3 w = new Vector3((float)Math.Cos(u) * s, (float)Math.Sin(u) * s, s1);
w = onb.transform(w, new Vector3());
state.traceDiffusePhoton(new Ray(state.getPoint(), w), power);
}
}
public void getSamples(ShadingState state)
{
if (Vector3.dot(dir, state.getGeoNormal()) < 0 && Vector3.dot(dir, state.getNormal()) < 0)
{
// project point onto source plane
float x = state.getPoint().x - src.x;
float y = state.getPoint().y - src.y;
float z = state.getPoint().z - src.z;
float t = ((x * dir.x) + (y * dir.y) + (z * dir.z));
if (t >= 0.0)
{
x -= (t * dir.x);
y -= (t * dir.y);
z -= (t * dir.z);
if (((x * x) + (y * y) + (z * z)) <= r2)
{
Point3 p = new Point3();
p.x = src.x + x;
p.y = src.y + y;
p.z = src.z + z;
LightSample dest = new LightSample();
dest.setShadowRay(new Ray(state.getPoint(), p));
dest.setRadiance(radiance, radiance);
dest.traceShadow(state);
state.addSample(dest);
}
}
}
}
public void ScatterPhoton(ShadingState state, Color power)
{
Color diffuse;
// make sure we are on the right side of the material
if (Vector3.dot(state.getNormal(), state.getRay().getDirection()) > 0.0)
{
state.getNormal().negate();
state.getGeoNormal().negate();
}
diffuse = getDiffuse(state);
state.storePhoton(state.getRay().getDirection(), power, diffuse);
float avg = diffuse.getAverage();
double rnd = state.getRandom(0, 0, 1);
if (rnd < avg)
{
// photon is scattered
power.mul(diffuse).mul(1.0f / avg);
OrthoNormalBasis onb = state.getBasis();
double u = 2 * Math.PI * rnd / avg;
double v = state.getRandom(0, 1, 1);
float s = (float)Math.Sqrt(v);
float s1 = (float)Math.Sqrt(1.0 - v);
Vector3 w = new Vector3((float)Math.Cos(u) * s, (float)Math.Sin(u) * s, s1);
w = onb.transform(w, new Vector3());
state.traceDiffusePhoton(new Ray(state.getPoint(), w), power);
}
}
public void getSamples(ShadingState state)
{
if (samples == null)
{
int n = state.getDiffuseDepth() > 0 ? 1 : numSamples;
for (int i = 0; i < n; i++)
{
// random offset on unit square, we use the infinite version of
// getRandom because the light sampling is adaptive
double randX = state.getRandom(i, 0, n);
double randY = state.getRandom(i, 1, n);
int x = 0;
while (randX >= colHistogram[x] && x < colHistogram.Length - 1)
x++;
float[] rowHistogram = imageHistogram[x];
int y = 0;
while (randY >= rowHistogram[y] && y < rowHistogram.Length - 1)
y++;
// sample from (x, y)
float u = (float)((x == 0) ? (randX / colHistogram[0]) : ((randX - colHistogram[x - 1]) / (colHistogram[x] - colHistogram[x - 1])));
float v = (float)((y == 0) ? (randY / rowHistogram[0]) : ((randY - rowHistogram[y - 1]) / (rowHistogram[y] - rowHistogram[y - 1])));
float px = ((x == 0) ? colHistogram[0] : (colHistogram[x] - colHistogram[x - 1]));
float py = ((y == 0) ? rowHistogram[0] : (rowHistogram[y] - rowHistogram[y - 1]));
float su = (x + u) / colHistogram.Length;
float sv = (y + v) / rowHistogram.Length;
float invP = (float)Math.Sin(sv * Math.PI) * jacobian / (n * px * py);
Vector3 dir = getDirection(su, sv);
basis.transform(dir);
if (Vector3.dot(dir, state.getGeoNormal()) > 0)
{
LightSample dest = new LightSample();
dest.setShadowRay(new Ray(state.getPoint(), dir));
dest.getShadowRay().setMax(float.MaxValue);
Color radiance = texture.getPixel(su, sv);
dest.setRadiance(radiance, radiance);
dest.getDiffuseRadiance().mul(invP);
dest.getSpecularRadiance().mul(invP);
dest.traceShadow(state);
state.addSample(dest);
}
}
}
else
{
for (int i = 0; i < numSamples; i++)
{
if (Vector3.dot(samples[i], state.getGeoNormal()) > 0 && Vector3.dot(samples[i], state.getNormal()) > 0)
{
LightSample dest = new LightSample();
dest.setShadowRay(new Ray(state.getPoint(), samples[i]));
dest.getShadowRay().setMax(float.MaxValue);
dest.setRadiance(colors[i], colors[i]);
dest.traceShadow(state);
state.addSample(dest);
}
}
}
}
public Color GetRadiance(ShadingState state)
{
// make sure we are on the right side of the material
state.faceforward();
// direct lighting
state.initLightSamples();
state.initCausticSamples();
Color d = getDiffuse(state);
Color lr = state.diffuse(d);
if (!state.includeSpecular)
return lr;
if (glossyness == 0)
{
float cos = state.getCosND();
float dn = 2 * cos;
Vector3 refDir = new Vector3();
refDir.x = (dn * state.getNormal().x) + state.getRay().getDirection().x;
refDir.y = (dn * state.getNormal().y) + state.getRay().getDirection().y;
refDir.z = (dn * state.getNormal().z) + state.getRay().getDirection().z;
Ray refRay = new Ray(state.getPoint(), refDir);
// compute Fresnel term
cos = 1 - cos;
float cos2 = cos * cos;
float cos5 = cos2 * cos2 * cos;
Color spec = getSpecular(state);
Color ret = Color.white();
ret.sub(spec);
ret.mul(cos5);
ret.add(spec);
return lr.add(ret.mul(state.traceReflection(refRay, 0)));
}
else
return lr.add(state.specularPhong(getSpecular(state), 2 / glossyness, numSamples));
}
public Color getRadiance(ShadingState state)
{
Point3[] p = new Point3[3];
if (!state.getTrianglePoints(p))
return getFillColor(state);
// transform points into camera space
Point3 center = state.getPoint();
Matrix4 w2c = state.getWorldToCamera();
center = w2c.transformP(center);
for (int i = 0; i < 3; i++)
p[i] = w2c.transformP(state.getInstance().transformObjectToWorld(p[i]));
float cn = 1.0f / (float)Math.Sqrt(center.x * center.x + center.y * center.y + center.z * center.z);
for (int i = 0, i2 = 2; i < 3; i2 = i, i++)
{
// compute orthogonal projection of the shading point onto each
// triangle edge as in:
// http://mathworld.wolfram.com/Point-LineDistance3-Dimensional.html
float t = (center.x - p[i].x) * (p[i2].x - p[i].x);
t += (center.y - p[i].y) * (p[i2].y - p[i].y);
t += (center.z - p[i].z) * (p[i2].z - p[i].z);
t /= p[i].distanceToSquared(p[i2]);
float projx = (1 - t) * p[i].x + t * p[i2].x;
float projy = (1 - t) * p[i].y + t * p[i2].y;
float projz = (1 - t) * p[i].z + t * p[i2].z;
float n = 1.0f / (float)Math.Sqrt(projx * projx + projy * projy + projz * projz);
// check angular width
float dot = projx * center.x + projy * center.y + projz * center.z;
if (dot * n * cn >= cosWidth)
return getLineColor(state);
}
return getFillColor(state);
}
public Color getRadiance(ShadingState state)
{
// don't use these - gather lights for sphere of directions
// gather lights
state.initLightSamples();
state.initCausticSamples();
Vector3 v = state.getRay().getDirection();
v.negate();
Vector3 h = new Vector3();
Vector3 t = state.getBasis().transform(new Vector3(0, 1, 0));
Color diff = Color.black();
Color spec = Color.black();
foreach (LightSample ls in state)
{
Vector3 l = ls.getShadowRay().getDirection();
float dotTL = Vector3.dot(t, l);
float sinTL = (float)Math.Sqrt(1 - dotTL * dotTL);
// float dotVL = Vector3.dot(v, l);
diff.madd(sinTL, ls.getDiffuseRadiance());
Vector3.add(v, l, h);
h.normalize();
float dotTH = Vector3.dot(t, h);
float sinTH = (float)Math.Sqrt(1 - dotTH * dotTH);
float s = (float)Math.Pow(sinTH, 10.0f);
spec.madd(s, ls.getSpecularRadiance());
}
Color c = Color.add(diff, spec, new Color());
// transparency
return(Color.blend(c, state.traceTransparency(), state.getV(), new Color()));
}
private int progressiveRenderNext(IntersectionState istate)
{
int TASK_SIZE = 16;
SmallBucket first = smallBucketQueue.Count > 0 ? smallBucketQueue.Dequeue() : null;
if (first == null)
{
return(0);
}
int ds = first.size / TASK_SIZE;
bool useMask = smallBucketQueue.Count != 0;
int mask = 2 * first.size / TASK_SIZE - 1;
int pixels = 0;
for (int i = 0, y = first.y; i < TASK_SIZE && y < imageHeight; i++, y += ds)
{
for (int j = 0, x = first.x; j < TASK_SIZE && x < imageWidth; j++, x += ds)
{
// check to see if this is a pixel from a higher level tile
if (useMask && (x & mask) == 0 && (y & mask) == 0)
{
continue;
}
int instance = (x & (sigma.Length - 1)) * sigma.Length + sigma[y & (sigma.Length - 1)];
double time = QMC.halton(1, instance);
double lensU = QMC.halton(2, instance);
double lensV = QMC.halton(3, instance);
ShadingState state = scene.getRadiance(istate, x, imageHeight - 1 - y, lensU, lensV, time, instance);
Color c = state != null?state.getResult() : Color.BLACK;
pixels++;
// fill region
display.imageFill(x, y, Math.Min(ds, imageWidth - x), Math.Min(ds, imageHeight - y), c);
}
}
if (first.size >= 2 * TASK_SIZE)
{
// generate child buckets
int size = (int)((uint)first.size >> 1);//>>>
for (int i = 0; i < 2; i++)
{
if (first.y + i * size < imageHeight)
{
for (int j = 0; j < 2; j++)
{
if (first.x + j * size < imageWidth)
{
SmallBucket b = new SmallBucket();
b.x = first.x + j * size;
b.y = first.y + i * size;
b.size = size;
b.constrast = 1.0f / size;
smallBucketQueue.Enqueue(b);
}
}
}
}
}
return(pixels);
}
public Color GetRadiance(ShadingState state)
{
Vector3 n = state.getNormal();
float f = n == null ? 1.0f : Math.Abs(state.getRay().dot(n));
return(new Color(state.getInstance().GetHashCode()).mul(f));
}
public void scatterPhoton(ShadingState state, Color power)
{
Color diffuse, specular;
// make sure we are on the right side of the material
state.faceforward();
diffuse = getDiffuse(state);
specular = getSpecular(state);
state.storePhoton(state.getRay().getDirection(), power, diffuse);
float d = diffuse.getAverage();
float r = specular.getAverage();
double rnd = state.getRandom(0, 0, 1);
if (rnd < d)
{
// photon is scattered
power.mul(diffuse).mul(1.0f / d);
OrthoNormalBasis onb = state.getBasis();
double u = 2 * Math.PI * rnd / d;
double v = state.getRandom(0, 1, 1);
float s = (float)Math.Sqrt(v);
float s1 = (float)Math.Sqrt(1.0 - v);
Vector3 w = new Vector3((float)Math.Cos(u) * s, (float)Math.Sin(u) * s, s1);
w = onb.transform(w, new Vector3());
state.traceDiffusePhoton(new Ray(state.getPoint(), w), power);
}
else if (rnd < d + r)
{
if (glossyness == 0)
{
float cos = -Vector3.dot(state.getNormal(), state.getRay().getDirection());
power.mul(diffuse).mul(1.0f / d);
// photon is reflected
float dn = 2 * cos;
Vector3 dir = new Vector3();
dir.x = (dn * state.getNormal().x) + state.getRay().getDirection().x;
dir.y = (dn * state.getNormal().y) + state.getRay().getDirection().y;
dir.z = (dn * state.getNormal().z) + state.getRay().getDirection().z;
state.traceReflectionPhoton(new Ray(state.getPoint(), dir), power);
}
else
{
float dn = 2.0f * state.getCosND();
// reflected direction
Vector3 refDir = new Vector3();
refDir.x = (dn * state.getNormal().x) + state.getRay().dx;
refDir.y = (dn * state.getNormal().y) + state.getRay().dy;
refDir.z = (dn * state.getNormal().z) + state.getRay().dz;
power.mul(spec).mul(1.0f / r);
OrthoNormalBasis onb = state.getBasis();
double u = 2 * Math.PI * (rnd - r) / r;
double v = state.getRandom(0, 1, 1);
float s = (float)Math.Pow(v, 1 / ((1.0f / glossyness) + 1));
float s1 = (float)Math.Sqrt(1 - s * s);
Vector3 w = new Vector3((float)Math.Cos(u) * s1, (float)Math.Sin(u) * s1, s);
w = onb.transform(w, new Vector3());
state.traceReflectionPhoton(new Ray(state.getPoint(), w), power);
}
}
}
public void prepareShadingState(ShadingState state)
{
state.init();
Instance i = state.getInstance();
state.getRay().getPoint(state.getPoint());
Ray r = state.getRay();
IShader s = i.getShader(0);
state.setShader(s != null ? s : this);
int primID = state.getPrimitiveID();
int hair = primID / numSegments;
int line = primID % numSegments;
int vRoot = hair * 3 * (numSegments + 1);
int v0 = vRoot + line * 3;
// tangent vector
Vector3 v = getTangent(line, v0, state.getV());
v = i.transformVectorObjectToWorld(v);
state.setBasis(OrthoNormalBasis.makeFromWV(v, new Vector3(-r.dx, -r.dy, -r.dz)));
state.getBasis().swapVW();
// normal
state.getNormal().set(0, 0, 1);
state.getBasis().transform(state.getNormal());
state.getGeoNormal().set(state.getNormal());
state.getUV().set(0, (line + state.getV()) / numSegments);
}
public Color getRadiance(ShadingState state)
{
if (!state.includeLights)
return Color.BLACK;
state.faceforward();
// emit constant radiance
return state.isBehind() ? Color.BLACK : radiance;
}
public Color GetRadiance(ShadingState state)
{
if (state.getUV() == null)
{
return(Color.BLACK);
}
return(new Color(state.getUV().x, state.getUV().y, 0));
}
public void ScatterPhoton(ShadingState state, Color power)
{
Color diffuse, specular;
// make sure we are on the right side of the material
state.faceforward();
diffuse = getDiffuse(state);
specular = getSpecular(state);
state.storePhoton(state.getRay().getDirection(), power, diffuse);
float d = diffuse.getAverage();
float r = specular.getAverage();
double rnd = state.getRandom(0, 0, 1);
if (rnd < d)
{
// photon is scattered
power.mul(diffuse).mul(1.0f / d);
OrthoNormalBasis onb = state.getBasis();
double u = 2 * Math.PI * rnd / d;
double v = state.getRandom(0, 1, 1);
float s = (float)Math.Sqrt(v);
float s1 = (float)Math.Sqrt(1.0 - v);
Vector3 w = new Vector3((float)Math.Cos(u) * s, (float)Math.Sin(u) * s, s1);
w = onb.transform(w, new Vector3());
state.traceDiffusePhoton(new Ray(state.getPoint(), w), power);
}
else if (rnd < d + r)
{
if (glossyness == 0)
{
float cos = -Vector3.dot(state.getNormal(), state.getRay().getDirection());
power.mul(diffuse).mul(1.0f / d);
// photon is reflected
float dn = 2 * cos;
Vector3 dir = new Vector3();
dir.x = (dn * state.getNormal().x) + state.getRay().getDirection().x;
dir.y = (dn * state.getNormal().y) + state.getRay().getDirection().y;
dir.z = (dn * state.getNormal().z) + state.getRay().getDirection().z;
state.traceReflectionPhoton(new Ray(state.getPoint(), dir), power);
}
else
{
float dn = 2.0f * state.getCosND();
// reflected direction
Vector3 refDir = new Vector3();
refDir.x = (dn * state.getNormal().x) + state.getRay().dx;
refDir.y = (dn * state.getNormal().y) + state.getRay().dy;
refDir.z = (dn * state.getNormal().z) + state.getRay().dz;
power.mul(spec).mul(1.0f / r);
OrthoNormalBasis onb = state.getBasis();
double u = 2 * Math.PI * (rnd - r) / r;
double v = state.getRandom(0, 1, 1);
float s = (float)Math.Pow(v, 1 / ((1.0f / glossyness) + 1));
float s1 = (float)Math.Sqrt(1 - s * s);
Vector3 w = new Vector3((float)Math.Cos(u) * s1, (float)Math.Sin(u) * s1, s);
w = onb.transform(w, new Vector3());
state.traceReflectionPhoton(new Ray(state.getPoint(), w), power);
}
}
}
public void getSamples(ShadingState state)
{
if (getNumSamples() <= 0)
return;
Vector3 wc = Point3.sub(center, state.getPoint(), new Vector3());
float l2 = wc.LengthSquared();
if (l2 <= r2)
return; // inside the sphere?
// top of the sphere as viewed from the current shading point
float topX = wc.x + state.getNormal().x * radius;
float topY = wc.y + state.getNormal().y * radius;
float topZ = wc.z + state.getNormal().z * radius;
if (state.getNormal().dot(topX, topY, topZ) <= 0)
return; // top of the sphere is below the horizon
float cosThetaMax = (float)Math.Sqrt(Math.Max(0, 1 - r2 / Vector3.dot(wc, wc)));
OrthoNormalBasis basis = OrthoNormalBasis.makeFromW(wc);
int samples = state.getDiffuseDepth() > 0 ? 1 : getNumSamples();
float scale = (float)(2 * Math.PI * (1 - cosThetaMax));
Color c = Color.mul(scale / samples, radiance);
for (int i = 0; i < samples; i++)
{
// random offset on unit square
double randX = state.getRandom(i, 0, samples);
double randY = state.getRandom(i, 1, samples);
// cone sampling
double cosTheta = (1 - randX) * cosThetaMax + randX;
double sinTheta = Math.Sqrt(1 - cosTheta * cosTheta);
double phi = randY * 2 * Math.PI;
Vector3 dir = new Vector3((float)(Math.Cos(phi) * sinTheta), (float)(Math.Sin(phi) * sinTheta), (float)cosTheta);
basis.transform(dir);
// check that the direction of the sample is the same as the
// normal
float cosNx = Vector3.dot(dir, state.getNormal());
if (cosNx <= 0)
continue;
float ocx = state.getPoint().x - center.x;
float ocy = state.getPoint().y - center.y;
float ocz = state.getPoint().z - center.z;
float qa = Vector3.dot(dir, dir);
float qb = 2 * ((dir.x * ocx) + (dir.y * ocy) + (dir.z * ocz));
float qc = ((ocx * ocx) + (ocy * ocy) + (ocz * ocz)) - r2;
double[] t = Solvers.solveQuadric(qa, qb, qc);
if (t == null)
continue;
LightSample dest = new LightSample();
// compute shadow ray to the sampled point
dest.setShadowRay(new Ray(state.getPoint(), dir));
// FIXME: arbitrary bias, should handle as in other places
dest.getShadowRay().setMax((float)t[0] - 1e-3f);
// prepare sample
dest.setRadiance(c, c);
dest.traceShadow(state);
state.addSample(dest);
}
}
public void getSamples(ShadingState state)
{
if (Vector3.dot(sunDirWorld, state.getGeoNormal()) > 0 && Vector3.dot(sunDirWorld, state.getNormal()) > 0)
{
LightSample dest = new LightSample();
dest.setShadowRay(new Ray(state.getPoint(), sunDirWorld));
dest.getShadowRay().setMax(float.MaxValue);
dest.setRadiance(sunColor, sunColor);
dest.traceShadow(state);
state.addSample(dest);
}
int n = state.getDiffuseDepth() > 0 ? 1 : numSkySamples;
for (int i = 0; i < n; i++)
{
// random offset on unit square, we use the infinite version of
// getRandom because the light sampling is adaptive
double randX = state.getRandom(i, 0, n);
double randY = state.getRandom(i, 1, n);
int x = 0;
while (randX >= colHistogram[x] && x < colHistogram.Length - 1)
{
x++;
}
float[] rowHistogram = imageHistogram[x];
int y = 0;
while (randY >= rowHistogram[y] && y < rowHistogram.Length - 1)
{
y++;
}
// sample from (x, y)
float u = (float)((x == 0) ? (randX / colHistogram[0]) : ((randX - colHistogram[x - 1]) / (colHistogram[x] - colHistogram[x - 1])));
float v = (float)((y == 0) ? (randY / rowHistogram[0]) : ((randY - rowHistogram[y - 1]) / (rowHistogram[y] - rowHistogram[y - 1])));
float px = ((x == 0) ? colHistogram[0] : (colHistogram[x] - colHistogram[x - 1]));
float py = ((y == 0) ? rowHistogram[0] : (rowHistogram[y] - rowHistogram[y - 1]));
float su = (x + u) / colHistogram.Length;
float sv = (y + v) / rowHistogram.Length;
float invP = (float)Math.Sin(sv * Math.PI) * jacobian / (n * px * py);
Vector3 localDir = getDirection(su, sv);
Vector3 dir = basis.transform(localDir, new Vector3());
if (Vector3.dot(dir, state.getGeoNormal()) > 0 && Vector3.dot(dir, state.getNormal()) > 0)
{
LightSample dest = new LightSample();
dest.setShadowRay(new Ray(state.getPoint(), dir));
dest.getShadowRay().setMax(float.MaxValue);
Color radiance = getSkyRGB(localDir);
dest.setRadiance(radiance, radiance);
dest.getDiffuseRadiance().mul(invP);
dest.getSpecularRadiance().mul(invP);
dest.traceShadow(state);
state.addSample(dest);
}
}
}
public Color getRadiance(ShadingState state)
{
// make sure we are on the right side of the material
state.faceforward();
// setup lighting
state.initLightSamples();
state.initCausticSamples();
return(state.diffuse(getDiffuse(state)));
}
public Color getRadiance(ShadingState state)
{
// make sure we are on the right side of the material
state.faceforward();
// setup lighting
state.initLightSamples();
state.initCausticSamples();
return state.diffuse(getDiffuse(state));
}
public Color GetRadiance(ShadingState state)
{
if (!state.includeSpecular)
return Color.BLACK;
Vector3 reflDir = new Vector3();
Vector3 refrDir = new Vector3();
state.faceforward();
float cos = state.getCosND();
bool inside = state.isBehind();
float neta = inside ? eta : 1.0f / eta;
float dn = 2 * cos;
reflDir.x = (dn * state.getNormal().x) + state.getRay().getDirection().x;
reflDir.y = (dn * state.getNormal().y) + state.getRay().getDirection().y;
reflDir.z = (dn * state.getNormal().z) + state.getRay().getDirection().z;
// refracted ray
float arg = 1 - (neta * neta * (1 - (cos * cos)));
bool tir = arg < 0;
if (tir)
refrDir.x = refrDir.y = refrDir.z = 0;
else
{
float nK = (neta * cos) - (float)Math.Sqrt(arg);
refrDir.x = (neta * state.getRay().dx) + (nK * state.getNormal().x);
refrDir.y = (neta * state.getRay().dy) + (nK * state.getNormal().y);
refrDir.z = (neta * state.getRay().dz) + (nK * state.getNormal().z);
}
// compute Fresnel terms
float cosTheta1 = Vector3.dot(state.getNormal(), reflDir);
float cosTheta2 = -Vector3.dot(state.getNormal(), refrDir);
float pPara = (cosTheta1 - eta * cosTheta2) / (cosTheta1 + eta * cosTheta2);
float pPerp = (eta * cosTheta1 - cosTheta2) / (eta * cosTheta1 + cosTheta2);
float kr = 0.5f * (pPara * pPara + pPerp * pPerp);
float kt = 1 - kr;
Color absorption = null;
if (inside && absorptionDistance > 0)
{
// this ray is inside the object and leaving it
// compute attenuation that occured along the ray
absorption = Color.mul(-state.getRay().getMax() / absorptionDistance, absorptionColor.copy().opposite()).exp();
if (absorption.isBlack())
return Color.BLACK; // nothing goes through
}
// refracted ray
Color ret = Color.black();
if (!tir)
{
ret.madd(kt, state.traceRefraction(new Ray(state.getPoint(), refrDir), 0)).mul(color);
}
if (!inside || tir)
ret.add(Color.mul(kr, state.traceReflection(new Ray(state.getPoint(), reflDir), 0)).mul(color));
return absorption != null ? ret.mul(absorption) : ret;
}
public Color getRadiance(ShadingState state)
{
Vector3 n = state.getNormal();
if (n == null)
return Color.BLACK;
float r = (n.x + 1) * 0.5f;
float g = (n.y + 1) * 0.5f;
float b = (n.z + 1) * 0.5f;
return new Color(r, g, b);
}
public Color getRadiance(ShadingState state)
{
// make sure we are on the right side of the material
state.faceforward();
// setup lighting
state.initLightSamples();
state.initCausticSamples();
// execute shader
return(state.diffuse(getDiffuse(state)).add(state.specularPhong(spec, power, numRays)));
}
public Color getRadiance(ShadingState state)
{
if (!state.includeLights)
{
return(Color.BLACK);
}
state.faceforward();
// emit constant radiance
return(state.isBehind() ? Color.BLACK : radiance);
}
public Color getRadiance(ShadingState state)
{
// make sure we are on the right side of the material
state.faceforward();
// setup lighting
state.initLightSamples();
state.initCausticSamples();
// execute shader
return state.diffuse(getDiffuse(state)).add(state.specularPhong(spec, power, numRays));
}
public Color getRadiance(ShadingState state)
{
state.faceforward();
state.initCausticSamples();
// integrate a diffuse function
Color lr = Color.black();
foreach (LightSample sample in state)
lr.madd(sample.dot(state.getNormal()), sample.getDiffuseRadiance());
return lr.mul(1.0f / (float)Math.PI);
}
public Color getIrradiance(ShadingState state, Color diffuseReflectance)
{
float cosTheta = Vector3.dot(up, state.getNormal());
float sin2 = (1 - cosTheta * cosTheta);
float sine = sin2 > 0 ? (float)Math.Sqrt(sin2) * 0.5f : 0;
if (cosTheta > 0)
return Color.blend(sky, ground, sine);
else
return Color.blend(ground, sky, sine);
}
public Color getGlobalRadiance(ShadingState state)
{
if (globalPhotonMap == null)
{
if (state.getShader() != null)
return state.getShader().getRadiance(state);
else
return Color.BLACK;
}
else
return globalPhotonMap.getRadiance(state.getPoint(), state.getNormal());
}
public void store(ShadingState state, Vector3 dir, Color power, Color diffuse)
{
Photon p = new Photon(state.getPoint(), state.getNormal(), dir, power, diffuse);
lock (lockObj)
{
storedPhotons++;
photonList.Add(p);
bounds.include(new Point3(p.x, p.y, p.z));
maxPower = Math.Max(maxPower, power.getMax());
}
}
private void renderBucket(IDisplay display, int bx, int by, int threadID, IntersectionState istate, ShadingCache cache)
{
// pixel sized extents
int x0 = bx * bucketSize;
int y0 = by * bucketSize;
int bw = Math.Min(bucketSize, imageWidth - x0);
int bh = Math.Min(bucketSize, imageHeight - y0);
// prepare bucket
display.imagePrepare(x0, y0, bw, bh, threadID);
Color[] bucketRGB = new Color[bw * bh];
float[] bucketAlpha = new float[bw * bh];
for (int y = 0, i = 0, cy = imageHeight - 1 - y0; y < bh; y++, cy--)
{
for (int x = 0, cx = x0; x < bw; x++, i++, cx++)
{
// sample pixel
Color c = Color.black();
float a = 0;
int instance = ((cx & ((1 << QMC.MAX_SIGMA_ORDER) - 1)) << QMC.MAX_SIGMA_ORDER) + QMC.sigma(cy & ((1 << QMC.MAX_SIGMA_ORDER) - 1), QMC.MAX_SIGMA_ORDER);
double jitterX = QMC.halton(0, instance);
double jitterY = QMC.halton(1, instance);
double jitterT = QMC.halton(2, instance);
double jitterU = QMC.halton(3, instance);
double jitterV = QMC.halton(4, instance);
for (int s = 0; s < numSamples; s++)
{
float rx = cx + 0.5f + (float)warpCubic(QMC.mod1(jitterX + s * invNumSamples));
float ry = cy + 0.5f + (float)warpCubic(QMC.mod1(jitterY + QMC.halton(0, s)));
double time = QMC.mod1(jitterT + QMC.halton(1, s));
double lensU = QMC.mod1(jitterU + QMC.halton(2, s));
double lensV = QMC.mod1(jitterV + QMC.halton(3, s));
ShadingState state = scene.getRadiance(istate, rx, ry, lensU, lensV, time, instance + s, 5, cache);
if (state != null)
{
c.add(state.getResult());
a++;
}
}
bucketRGB[i] = c.mul(invNumSamples);
bucketAlpha[i] = a * invNumSamples;
if (cache != null)
{
cache.reset();
}
}
}
// update pixels
display.imageUpdate(x0, y0, bw, bh, bucketRGB, bucketAlpha);
}
public void store(ShadingState state, Vector3 dir, Color power, Color diffuse)
{
state.faceforward();
PointLight vpl = new PointLight();
vpl.p = state.getPoint();
vpl.n = state.getNormal();
vpl.power = power;
lock (lockObj)
{
virtualLights.Add(vpl);
}
}
public void add(ShadingState state)
{
if (n == 0)
{
c = Color.black();
}
if (state != null)
{
c.add(state.getResult());
checkNanInf();
}
n++;
}
public void add(ShadingState state)
{
if (n == 0)
{
c = Color.black();
}
if (state != null)
{
c.add(state.getResult());
alpha += state.getInstance() == null ? 0 : 1;
}
n++;
}
public Color getRadiance(ShadingState state)
{
state.faceforward();
state.initCausticSamples();
// integrate a diffuse function
Color lr = Color.black();
foreach (LightSample sample in state)
{
lr.madd(sample.dot(state.getNormal()), sample.getDiffuseRadiance());
}
return(lr.mul(1.0f / (float)Math.PI));
}
public void getSamples(ShadingState state)
{
if (lightBounds.contains(state.getPoint()) && state.getPoint().z < maxZ)
{
int n = state.getDiffuseDepth() > 0 ? 1 : samples;
float a = area / n;
for (int i = 0; i < n; i++)
{
// random offset on unit square, we use the infinite version of
// getRandom
// because the light sampling is adaptive
double randX = state.getRandom(i, 0);
double randY = state.getRandom(i, 1);
Point3 p = new Point3();
p.x = (float)(lxmin * (1 - randX) + lxmax * randX);
p.y = (float)(lymin * (1 - randY) + lymax * randY);
p.z = maxZ - 0.001f;
LightSample dest = new LightSample();
// prepare shadow ray to sampled point
dest.setShadowRay(new Ray(state.getPoint(), p));
// check that the direction of the sample is the same as the
// normal
float cosNx = dest.dot(state.getNormal());
if (cosNx <= 0)
{
return;
}
// light source facing point ?
// (need to check with light source's normal)
float cosNy = dest.getShadowRay().dz;
if (cosNy > 0)
{
// compute geometric attenuation and probability scale
// factor
float r = dest.getShadowRay().getMax();
float g = cosNy / (r * r);
float scale = g * a;
// set sample radiance
dest.setRadiance(radiance, radiance);
dest.getDiffuseRadiance().mul(scale);
dest.getSpecularRadiance().mul(scale);
dest.traceShadow(state);
state.addSample(dest);
}
}
}
}
public Color GetRadiance(ShadingState state)
{
Vector3 n = state.getNormal();
if (n == null)
{
return(Color.BLACK);
}
float r = (n.x + 1) * 0.5f;
float g = (n.y + 1) * 0.5f;
float b = (n.z + 1) * 0.5f;
return(new Color(r, g, b));
}
public Color getIrradiance(ShadingState state, Color diffuseReflectance)
{
float cosTheta = Vector3.dot(up, state.getNormal());
float sin2 = (1 - cosTheta * cosTheta);
float sine = sin2 > 0 ? (float)Math.Sqrt(sin2) * 0.5f : 0;
if (cosTheta > 0)
{
return(Color.blend(sky, ground, sine));
}
else
{
return(Color.blend(ground, sky, sine));
}
}
public Color GetRadiance(ShadingState state)
{
if (state.getNormal() == null)
{
// if this shader has been applied to an infinite instance because of shader overrides
// run the default shader, otherwise, just shade black
return state.getShader() != this ? state.getShader().GetRadiance(state) : Color.BLACK;
}
// make sure we are on the right side of the material
state.faceforward();
// setup lighting
state.initLightSamples();
state.initCausticSamples();
return state.diffuse(Color.GRAY);
}
public Color GetRadiance(ShadingState state)
{
if (state.getNormal() == null)
{
// if this shader has been applied to an infinite instance because of shader overrides
// run the default shader, otherwise, just shade black
return(state.getShader() != this ? state.getShader().GetRadiance(state) : Color.BLACK);
}
// make sure we are on the right side of the material
state.faceforward();
// setup lighting
state.initLightSamples();
state.initCausticSamples();
return(state.diffuse(Color.GRAY));
}
public void store(ShadingState state, Vector3 dir, Color power, Color diffuse)
{
if (((state.getDiffuseDepth() == 0) && (state.getReflectionDepth() > 0 || state.getRefractionDepth() > 0)))
{
// this is a caustic photon
Photon p = new Photon(state.getPoint(), dir, power);
lock (lockObj)
{
storedPhotons++;
photonList.Add(p);
bounds.include(new Point3(p.x, p.y, p.z));
maxPower = Math.Max(maxPower, power.getMax());
}
}
}
public void getSamples(ShadingState state)
{
Vector3 d = Point3.sub(lightPoint, state.getPoint(), new Vector3());
if (Vector3.dot(d, state.getNormal()) > 0 && Vector3.dot(d, state.getGeoNormal()) > 0)
{
LightSample dest = new LightSample();
// prepare shadow ray
dest.setShadowRay(new Ray(state.getPoint(), lightPoint));
float scale = 1.0f / (float)(4 * Math.PI * lightPoint.distanceToSquared(state.getPoint()));
dest.setRadiance(power, power);
dest.getDiffuseRadiance().mul(scale);
dest.getSpecularRadiance().mul(scale);
dest.traceShadow(state);
state.addSample(dest);
}
}
public void getSamples(ShadingState state)
{
Vector3 d = Point3.sub(lightPoint, state.getPoint(), new Vector3());
if (Vector3.dot(d, state.getNormal()) > 0 && Vector3.dot(d, state.getGeoNormal()) > 0)
{
LightSample dest = new LightSample();
// prepare shadow ray
dest.setShadowRay(new Ray(state.getPoint(), lightPoint));
float scale = 1.0f / (float)(4 * Math.PI * lightPoint.distanceToSquared(state.getPoint()));
dest.setRadiance(power, power);
dest.getDiffuseRadiance().mul(scale);
dest.getSpecularRadiance().mul(scale);
dest.traceShadow(state);
state.addSample(dest);
}
}
public void ScatterPhoton(ShadingState state, Color power)
{
float avg = color.getAverage();
double rnd = state.getRandom(0, 0, 1);
if (rnd >= avg)
return;
state.faceforward();
float cos = state.getCosND();
power.mul(color).mul(1.0f / avg);
// photon is reflected
float dn = 2 * cos;
Vector3 dir = new Vector3();
dir.x = (dn * state.getNormal().x) + state.getRay().getDirection().x;
dir.y = (dn * state.getNormal().y) + state.getRay().getDirection().y;
dir.z = (dn * state.getNormal().z) + state.getRay().getDirection().z;
state.traceReflectionPhoton(new Ray(state.getPoint(), dir), power);
}
public void prepareShadingState(ShadingState state)
{
state.init();
state.getRay().getPoint(state.getPoint());
Instance parent = state.getInstance();
Vector3 worldNormal = state.transformNormalObjectToWorld(normal);
state.getNormal().set(worldNormal);
state.getGeoNormal().set(worldNormal);
state.setShader(parent.getShader(0));
state.setModifier(parent.getModifier(0));
Point3 p = state.transformWorldToObject(state.getPoint());
float hu, hv;
switch (k)
{
case 0:
{
hu = p.y;
hv = p.z;
break;
}
case 1:
{
hu = p.z;
hv = p.x;
break;
}
case 2:
{
hu = p.x;
hv = p.y;
break;
}
default:
hu = hv = 0;
break;
}
state.getUV().x = hu * bnu + hv * bnv + bnd;
state.getUV().y = hu * cnu + hv * cnv + cnd;
state.setBasis(OrthoNormalBasis.makeFromW(normal));
}
public void prepareShadingState(ShadingState state)
{
state.init();
state.getRay().getPoint(state.getPoint());
Instance parent = state.getInstance();
Point3 n = parent.transformWorldToObject(state.getPoint());
state.getNormal().set(n.x * (2 * n.x * n.x - 1), n.y * (2 * n.y * n.y - 1), n.z * (2 * n.z * n.z - 1));
state.getNormal().normalize();
state.setShader(parent.getShader(0));
state.setModifier(parent.getModifier(0));
// into world space
Vector3 worldNormal = parent.transformNormalObjectToWorld(state.getNormal());
state.getNormal().set(worldNormal);
state.getNormal().normalize();
state.getGeoNormal().set(state.getNormal());
// create basis in world space
state.setBasis(OrthoNormalBasis.makeFromW(state.getNormal()));
}
public Color getGlobalRadiance(ShadingState state)
{
if (globalPhotonMap == null)
{
if (state.getShader() != null)
{
return(state.getShader().GetRadiance(state));
}
else
{
return(Color.BLACK);
}
}
else
{
return(globalPhotonMap.getRadiance(state.getPoint(), state.getNormal()));
}
}
public Color GetRadiance(ShadingState state)
{
int side = state.getPrimitiveID();
Color kd = null;
switch (side)
{
case 0:
kd = left;
break;
case 1:
kd = right;
break;
case 3:
kd = back;
break;
case 4:
kd = bottom;
break;
case 5:
float lx = state.getPoint().x;
float ly = state.getPoint().y;
if (lx >= lxmin && lx < lxmax && ly >= lymin && ly < lymax && state.getRay().dz > 0)
{
return(state.includeLights ? radiance : Color.BLACK);
}
kd = top;
break;
default:
Debug.Assert(false);
break;
}
// make sure we are on the right side of the material
state.faceforward();
// setup lighting
state.initLightSamples();
state.initCausticSamples();
return(state.diffuse(kd));
}
public void scatterPhoton(ShadingState state, Color power)
{
// make sure we are on the right side of the material
state.faceforward();
Color d = getDiffuse(state);
state.storePhoton(state.getRay().getDirection(), power, d);
float avgD = d.getAverage();
float avgS = spec.getAverage();
double rnd = state.getRandom(0, 0, 1);
if (rnd < avgD)
{
// photon is scattered diffusely
power.mul(d).mul(1.0f / avgD);
OrthoNormalBasis onb = state.getBasis();
double u = 2 * Math.PI * rnd / avgD;
double v = state.getRandom(0, 1, 1);
float s = (float)Math.Sqrt(v);
float s1 = (float)Math.Sqrt(1.0f - v);
Vector3 w = new Vector3((float)Math.Cos(u) * s, (float)Math.Sin(u) * s, s1);
w = onb.transform(w, new Vector3());
state.traceDiffusePhoton(new Ray(state.getPoint(), w), power);
}
else if (rnd < avgD + avgS)
{
// photon is scattered specularly
float dn = 2.0f * state.getCosND();
// reflected direction
Vector3 refDir = new Vector3();
refDir.x = (dn * state.getNormal().x) + state.getRay().dx;
refDir.y = (dn * state.getNormal().y) + state.getRay().dy;
refDir.z = (dn * state.getNormal().z) + state.getRay().dz;
power.mul(spec).mul(1.0f / avgS);
OrthoNormalBasis onb = state.getBasis();
double u = 2 * Math.PI * (rnd - avgD) / avgS;
double v = state.getRandom(0, 1, 1);
float s = (float)Math.Pow(v, 1 / (this.power + 1));
float s1 = (float)Math.Sqrt(1 - s * s);
Vector3 w = new Vector3((float)Math.Cos(u) * s1, (float)Math.Sin(u) * s1, s);
w = onb.transform(w, new Vector3());
state.traceReflectionPhoton(new Ray(state.getPoint(), w), power);
}
}
public void modify(ShadingState state)
{
Point3 p = state.transformWorldToObject(state.getPoint());
p.x *= size;
p.y *= size;
p.z *= size;
Vector3 normal = state.transformNormalWorldToObject(state.getNormal());
double f0 = f(p.x, p.y, p.z);
double fx = f(p.x + .0001, p.y, p.z);
double fy = f(p.x, p.y + .0001, p.z);
double fz = f(p.x, p.y, p.z + .0001);
normal.x -= scale * (float)((fx - f0) / .0001);
normal.y -= scale * (float)((fy - f0) / .0001);
normal.z -= scale * (float)((fz - f0) / .0001);
normal.normalize();
state.getNormal().set(state.transformNormalObjectToWorld(normal));
state.getNormal().normalize();
state.setBasis(OrthoNormalBasis.makeFromW(state.getNormal()));
}
public void prepareShadingState(ShadingState state)
{
state.init();
state.getRay().getPoint(state.getPoint());
Point3 localPoint = state.transformWorldToObject(state.getPoint());
localPoint.x -= particles[3 * state.getPrimitiveID() + 0];
localPoint.y -= particles[3 * state.getPrimitiveID() + 1];
localPoint.z -= particles[3 * state.getPrimitiveID() + 2];
state.getNormal().set(localPoint.x, localPoint.y, localPoint.z);
state.getNormal().normalize();
state.setShader(state.getInstance().getShader(0));
state.setModifier(state.getInstance().getModifier(0));
// into object space
Vector3 worldNormal = state.transformNormalObjectToWorld(state.getNormal());
state.getNormal().set(worldNormal);
state.getNormal().normalize();
state.getGeoNormal().set(state.getNormal());
state.setBasis(OrthoNormalBasis.makeFromW(state.getNormal()));
}
public Color GetRadiance(ShadingState state)
{
if (!state.includeSpecular)
return Color.BLACK;
state.faceforward();
float cos = state.getCosND();
float dn = 2 * cos;
Vector3 refDir = new Vector3();
refDir.x = (dn * state.getNormal().x) + state.getRay().getDirection().x;
refDir.y = (dn * state.getNormal().y) + state.getRay().getDirection().y;
refDir.z = (dn * state.getNormal().z) + state.getRay().getDirection().z;
Ray refRay = new Ray(state.getPoint(), refDir);
// compute Fresnel term
cos = 1 - cos;
float cos2 = cos * cos;
float cos5 = cos2 * cos2 * cos;
Color ret = Color.white();
ret.sub(color);
ret.mul(cos5);
ret.add(color);
return ret.mul(state.traceReflection(refRay, 0));
}
public Color getGlobalRadiance(ShadingState state)
{
Point3 p = state.getPoint();
Vector3 n = state.getNormal();
int set = (int)(state.getRandom(0, 1, 1) * numSets);
float maxAvgPow = 0;
float minDist = 1;
Color pow = null;
foreach (PointLight vpl in virtualLights[set])
{
maxAvgPow = Math.Max(maxAvgPow, vpl.power.getAverage());
if (Vector3.dot(n, vpl.n) > 0.9f)
{
float d = vpl.p.distanceToSquared(p);
if (d < minDist)
{
pow = vpl.power;
minDist = d;
}
}
}
return pow == null ? Color.BLACK : pow.copy().mul(1.0f / maxAvgPow);
}
public void ScatterPhoton(ShadingState state, Color power)
{
Color diffuse;
// make sure we are on the right side of the material
state.faceforward();
diffuse = getDiffuse(state);
state.storePhoton(state.getRay().getDirection(), power, diffuse);
float d = diffuse.getAverage();
float r = d * refl;
double rnd = state.getRandom(0, 0, 1);
if (rnd < d)
{
// photon is scattered
power.mul(diffuse).mul(1.0f / d);
OrthoNormalBasis onb = state.getBasis();
double u = 2 * Math.PI * rnd / d;
double v = state.getRandom(0, 1, 1);
float s = (float)Math.Sqrt(v);
float s1 = (float)Math.Sqrt(1.0 - v);
Vector3 w = new Vector3((float)Math.Cos(u) * s, (float)Math.Sin(u) * s, s1);
w = onb.transform(w, new Vector3());
state.traceDiffusePhoton(new Ray(state.getPoint(), w), power);
}
else if (rnd < d + r)
{
float cos = -Vector3.dot(state.getNormal(), state.getRay().getDirection());
power.mul(diffuse).mul(1.0f / d);
// photon is reflected
float dn = 2 * cos;
Vector3 dir = new Vector3();
dir.x = (dn * state.getNormal().x) + state.getRay().getDirection().x;
dir.y = (dn * state.getNormal().y) + state.getRay().getDirection().y;
dir.z = (dn * state.getNormal().z) + state.getRay().getDirection().z;
state.traceReflectionPhoton(new Ray(state.getPoint(), dir), power);
}
}
public void getSamples(ShadingState state)
{
if (storedPhotons == 0)
return;
NearestPhotons np = new NearestPhotons(state.getPoint(), gatherNum, gatherRadius * gatherRadius);
locatePhotons(np);
if (np.found < 8)
return;
Point3 ppos = new Point3();
Vector3 pdir = new Vector3();
Vector3 pvec = new Vector3();
float invArea = 1.0f / ((float)Math.PI * np.dist2[0]);
float maxNDist = np.dist2[0] * 0.05f;
float f2r2 = 1.0f / (filterValue * filterValue * np.dist2[0]);
float fInv = 1.0f / (1.0f - 2.0f / (3.0f * filterValue));
for (int i = 1; i <= np.found; i++)
{
Photon phot = np.index[i];
Vector3.decode(phot.dir, pdir);
float cos = -Vector3.dot(pdir, state.getNormal());
if (cos > 0.001)
{
ppos.set(phot.x, phot.y, phot.z);
Point3.sub(ppos, state.getPoint(), pvec);
float pcos = Vector3.dot(pvec, state.getNormal());
if ((pcos < maxNDist) && (pcos > -maxNDist))
{
LightSample sample = new LightSample();
sample.setShadowRay(new Ray(state.getPoint(), pdir.negate()));
sample.setRadiance(new Color().setRGBE(np.index[i].power).mul(invArea / cos), Color.BLACK);
sample.getDiffuseRadiance().mul((1.0f - (float)Math.Sqrt(np.dist2[i] * f2r2)) * fInv);
state.addSample(sample);
}
}
}
}
public Color getIrradiance(ShadingState state, Color diffuseReflectance)
{
OrthoNormalBasis onb = state.getBasis();
Vector3 w = new Vector3();
Color result = Color.black();
for (int i = 0; i < samples; i++)
{
float xi = (float)state.getRandom(i, 0, samples);
float xj = (float)state.getRandom(i, 1, samples);
float phi = (float)(2 * Math.PI * xi);
float cosPhi = (float)Math.Cos(phi);
float sinPhi = (float)Math.Sin(phi);
float sinTheta = (float)Math.Sqrt(xj);
float cosTheta = (float)Math.Sqrt(1.0f - xj);
w.x = cosPhi * sinTheta;
w.y = sinPhi * sinTheta;
w.z = cosTheta;
onb.transform(w);
Ray r = new Ray(state.getPoint(), w);
r.setMax(maxDist);
result.add(Color.blend(bright, dark, state.traceShadow(r)));
}
return result.mul((float)Math.PI / samples);
}