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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
/* SPDX-License-Identifier: Apache-2.0
* Copyright 2011-2022 Blender Foundation */
#pragma once
CCL_NAMESPACE_BEGIN
/* See "Tracing Ray Differentials", Homan Igehy, 1999. */
ccl_device void differential_transfer(ccl_private differential3 *surface_dP,
const differential3 ray_dP,
float3 ray_D,
const differential3 ray_dD,
float3 surface_Ng,
float ray_t)
{
/* ray differential transfer through homogeneous medium, to
* compute dPdx/dy at a shading point from the incoming ray */
float3 tmp = ray_D / dot(ray_D, surface_Ng);
float3 tmpx = ray_dP.dx + ray_t * ray_dD.dx;
float3 tmpy = ray_dP.dy + ray_t * ray_dD.dy;
surface_dP->dx = tmpx - dot(tmpx, surface_Ng) * tmp;
surface_dP->dy = tmpy - dot(tmpy, surface_Ng) * tmp;
}
ccl_device void differential_incoming(ccl_private 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;
}
ccl_device void differential_dudv(ccl_private differential *du,
ccl_private 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 */
float xn = fabsf(Ng.x);
float yn = fabsf(Ng.y);
float zn = fabsf(Ng.z);
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.
*
* dP.dx = dPdu * dudx + dPdv * dvdx;
* dP.dy = dPdu * dudy + dPdv * dvdy; */
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;
}
ccl_device differential differential_zero()
{
differential d;
d.dx = 0.0f;
d.dy = 0.0f;
return d;
}
ccl_device differential3 differential3_zero()
{
differential3 d;
d.dx = zero_float3();
d.dy = zero_float3();
return d;
}
/* Compact ray differentials that are just a scale to reduce memory usage and
* access cost in GPU.
*
* See above for more accurate reference implementations.
*
* TODO: also store the more compact version in ShaderData and recompute where
* needed? */
ccl_device_forceinline float differential_zero_compact()
{
return 0.0f;
}
ccl_device_forceinline float differential_make_compact(const differential3 D)
{
return 0.5f * (len(D.dx) + len(D.dy));
}
ccl_device_forceinline void differential_transfer_compact(ccl_private differential3 *surface_dP,
const float ray_dP,
const float3 /* ray_D */,
const float ray_dD,
const float3 surface_Ng,
const float ray_t)
{
/* ray differential transfer through homogeneous medium, to
* compute dPdx/dy at a shading point from the incoming ray */
float scale = ray_dP + ray_t * ray_dD;
float3 dx, dy;
make_orthonormals(surface_Ng, &dx, &dy);
surface_dP->dx = dx * scale;
surface_dP->dy = dy * scale;
}
ccl_device_forceinline void differential_incoming_compact(ccl_private differential3 *dI,
const float3 D,
const float dD)
{
/* compute dIdx/dy at a shading point, we just need to negate the
* differential of the ray direction */
float3 dx, dy;
make_orthonormals(D, &dx, &dy);
dI->dx = dD * dx;
dI->dy = dD * dy;
}
CCL_NAMESPACE_END
|
