2011-04-27 11:58:34 +00:00
|
|
|
/*
|
2013-08-18 14:16:15 +00:00
|
|
|
* Copyright 2011-2013 Blender Foundation
|
2011-04-27 11:58:34 +00:00
|
|
|
*
|
2013-08-18 14:16:15 +00:00
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
2011-04-27 11:58:34 +00:00
|
|
|
*
|
2013-08-18 14:16:15 +00:00
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
2011-04-27 11:58:34 +00:00
|
|
|
*
|
2013-08-18 14:16:15 +00:00
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License
|
2011-04-27 11:58:34 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
CCL_NAMESPACE_BEGIN
|
|
|
|
|
|
|
|
/* See "Tracing Ray Differentials", Homan Igehy, 1999. */
|
|
|
|
|
|
|
|
__device void differential_transfer(differential3 *dP_, const differential3 dP, float3 D, const differential3 dD, float3 Ng, float t)
|
|
|
|
{
|
2012-07-16 23:23:33 +00:00
|
|
|
/* ray differential transfer through homogeneous medium, to
|
2011-04-27 11:58:34 +00:00
|
|
|
* compute dPdx/dy at a shading point from the incoming ray */
|
|
|
|
|
|
|
|
float3 tmp = D/dot(D, Ng);
|
|
|
|
float3 tmpx = dP.dx + t*dD.dx;
|
|
|
|
float3 tmpy = dP.dy + t*dD.dy;
|
|
|
|
|
|
|
|
dP_->dx = tmpx - dot(tmpx, Ng)*tmp;
|
|
|
|
dP_->dy = tmpy - dot(tmpy, Ng)*tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
__device void differential_incoming(differential3 *dI, const differential3 dD)
|
|
|
|
{
|
|
|
|
/* compute dIdx/dy at a shading point, we just need to negate the
|
|
|
|
* differential of the ray direction */
|
|
|
|
|
|
|
|
dI->dx = -dD.dx;
|
|
|
|
dI->dy = -dD.dy;
|
|
|
|
}
|
|
|
|
|
|
|
|
__device void differential_dudv(differential *du, differential *dv, float3 dPdu, float3 dPdv, differential3 dP, float3 Ng)
|
|
|
|
{
|
|
|
|
/* now we have dPdx/dy from the ray differential transfer, and dPdu/dv
|
|
|
|
* from the primitive, we can compute dudx/dy and dvdx/dy. these are
|
|
|
|
* mainly used for differentials of arbitrary mesh attributes. */
|
|
|
|
|
|
|
|
/* find most stable axis to project to 2D */
|
2012-06-09 18:56:12 +00:00
|
|
|
float xn = fabsf(Ng.x);
|
|
|
|
float yn = fabsf(Ng.y);
|
|
|
|
float zn = fabsf(Ng.z);
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
if(zn < xn || zn < yn) {
|
|
|
|
if(yn < xn || yn < zn) {
|
|
|
|
dPdu.x = dPdu.y;
|
|
|
|
dPdv.x = dPdv.y;
|
|
|
|
dP.dx.x = dP.dx.y;
|
|
|
|
dP.dy.x = dP.dy.y;
|
|
|
|
}
|
|
|
|
|
|
|
|
dPdu.y = dPdu.z;
|
|
|
|
dPdv.y = dPdv.z;
|
|
|
|
dP.dx.y = dP.dx.z;
|
|
|
|
dP.dy.y = dP.dy.z;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* using Cramer's rule, we solve for dudx and dvdx in a 2x2 linear system,
|
|
|
|
* and the same for dudy and dvdy. the denominator is the same for both
|
|
|
|
* solutions, so we compute it only once.
|
|
|
|
*
|
2012-01-20 17:49:17 +00:00
|
|
|
* dP.dx = dPdu * dudx + dPdv * dvdx;
|
|
|
|
* dP.dy = dPdu * dudy + dPdv * dvdy; */
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
float det = (dPdu.x*dPdv.y - dPdv.x*dPdu.y);
|
|
|
|
|
|
|
|
if(det != 0.0f)
|
|
|
|
det = 1.0f/det;
|
|
|
|
|
|
|
|
du->dx = (dP.dx.x*dPdv.y - dP.dx.y*dPdv.x)*det;
|
|
|
|
dv->dx = (dP.dx.y*dPdu.x - dP.dx.x*dPdu.y)*det;
|
|
|
|
|
|
|
|
du->dy = (dP.dy.x*dPdv.y - dP.dy.y*dPdv.x)*det;
|
|
|
|
dv->dy = (dP.dy.y*dPdu.x - dP.dy.x*dPdu.y)*det;
|
|
|
|
}
|
|
|
|
|
2013-05-03 21:34:51 +00:00
|
|
|
__device differential differential_zero()
|
|
|
|
{
|
|
|
|
differential d;
|
|
|
|
d.dx = 0.0f;
|
|
|
|
d.dy = 0.0f;
|
|
|
|
|
|
|
|
return d;
|
|
|
|
}
|
|
|
|
|
|
|
|
__device differential3 differential3_zero()
|
|
|
|
{
|
|
|
|
differential3 d;
|
|
|
|
d.dx = make_float3(0.0f, 0.0f, 0.0f);
|
|
|
|
d.dy = make_float3(0.0f, 0.0f, 0.0f);
|
|
|
|
|
|
|
|
return d;
|
|
|
|
}
|
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
CCL_NAMESPACE_END
|
|
|
|
|