View-Independent Adjoint Light Tracing for Lighting Design Optimization

Differentiable rendering methods promise the ability to optimize various parameters of 3d scenes to achieve a desired result. However, lighting design has so far received little attention in this field. In this paper, we introduce a method that enables continuous optimization of the arrangement of luminaires in a 3d scene via differentiable light tracing. Our experiments show two major issues when attempting to apply existing methods from differentiable path tracing to this problem: first, many rendering methods produce images, which restricts the ability of a designer to define lighting objectives to image space. Second, most previous methods are designed for scene geometry or material optimization and have not been extensively tested for the case of optimizing light sources. Currently available differentiable ray-tracing methods do not provide satisfactory performance, even on fairly basic test cases in our experience. In this paper, we propose a novel adjoint light tracing method that overcomes these challenges and enables gradient-based lighting design optimization in a view-independent (camera-free) way. Thus, we allow the user to paint illumination targets directly onto the 3d scene or use existing baked illumination data (e.g., light maps). Using modern ray-tracing hardware, we achieve interactive performance. We find light tracing advantageous over path tracing in this setting, as it naturally handles irregular geometry, resulting in less noise and improved optimization convergence. We compare our adjoint gradients to state-of-the-art image-based differentiable rendering methods. We also demonstrate that our gradient data works with various common optimization algorithms, providing good convergence behaviour. Qualitative comparisons with real-world scenes underline the practical applicability of our method.


INTRODUCTION
Lighting plays an often overlooked but central role in our daily lives.It contributes to making a home feel relaxing, a workplace efficient, and is subject to important requirements in professional environments such as office spaces, hospitals, and factories.While artistic applications usually require manual luminaire placement, simple grid-like patterns are widespread in office spaces.Both scenarios can benefit from automated optimization, reducing the workload on artists, or producing more comfortable office lighting.Widely used commercial lighting design tools, such as DIALux [2022] and Relux [2022], are limited to simple light interactions and require manual editing of luminaires to achieve the desired result.
Physically based primal rendering, i.e., simulating light transport in a 3d scene according to the rendering equation, has a longstanding history in computer graphics.Conversely, inverse rendering methods aim to match a scene's appearance to one or more target images.These existing view-dependent methods are technically capable of optimizing light sources in an image-based framework, but have practical limitations: as indicated by our comparisons, their convergence behaviour and runtime performance are insufficient for interactive lighting optimization.Furthermore, they quickly become problematic for complex scenes, as many cameras are required to capture all areas of interest.Additionally, this approach would raise the question of how many (and where) cameras should be placed, and how to define their illumination targets.Consequently, we avoid cameras in favour of a view-independent approach.
Currently, no solution for view-independent (i.e., camera-free) differentiable rendering exists.Moving from camera-based inverse renderers (Mitsuba, PSDR) to view-independent optimization requires a spatio-directional data structure that can be updated and edited quickly.In order to achieve interactive performance, we also require an efficient and robust gradient formulation that can be evaluated on the GPU.In this paper, we propose an interactive and fully view-independent inverse rendering framework, building upon a novel analytical adjoint formulation.The absence of a predefined camera view, and optimization parameters that are associated with light sources, motivate a light-tracing global-illumination method, instead of more common path-tracing approaches.
Previously, automatic differentiation (AD) has been widely used.Our tests show that applying AD directly to light tracing suffers from systematic errors that prevent optimization convergence.Zhang et al. [2020] describe an AD path-space formulation, which is, in principle, also applicable to paths constructed via light tracing.Conversely, we present an analytically differentiable adjoint light-tracing method, which enables a GPU-accelerated implementation.
Overall, we present the following contributions in this paper: • An efficient adjoint gradient formulation for differentiable light tracing, which outperforms comparable path-tracing approaches, and • an efficiently updatable view-independent radiance data structure.• This combination allows us to solve lighting design optimization tasks, while taking global illumination into account.• We also present a novel visualization of point-wise adjoint gradient contributions.

RELATED WORK
Here, we briefly summarize relevant work on global-illumination rendering, before discussing recent advances in differentiable rendering.Furthermore, we introduce approaches that have investigated the lighting design problem from other directions, such as procedural modelling.

Primal rendering
In the following, we classify related work in four categories, as illustrated in the inset image.Path tracing, one of the most fundamental methods for physically based rendering, applies Monte Carlo integration to solve the rendering equation [Kajiya 1986;Veach 1998].
Similar methods have been extensively used to render physically realistic images (category a).Pre-computed light-transport methods, on the other hand, such as radiosity [Goral et al. 1984;Greenberg et al. 1986], focus on solving global illumination for all surfaces in a 3d scene (category b) rather than for a view-dependent image.
L dL More recently, these radiosity methods have been extended to incorporate glossy surfaces [Hašan et al. 2009;Krivanek et al. 2005;Omidvar et al. 2015;Sillion et al. 1991;Sloan et al. 2002] and also enable fast incremental updates allowing for interactive frame rates [Luksch et al. 2019].Similarly, photon mapping [Jensen 1995] is a two-pass process, where illumination data is first cast into the 3d scene by tracing light paths, while the second pass gathers this data to compute the final image.We take inspiration from these latter approaches, constructing a spatio-directional radiance data structure in order to enable view-independent differentiable rendering (category d).The key ideas of our adjoint light-tracing approach would in principle also be applicable to other pre-computed lighttransport methods and radiance-field data structures, such as the recent work by Yu et al. [2021], as well as photon tracing, virtual point light, or light probe approaches.

Differentiable rendering
Previous work in (physically based) inverse rendering has, so far, focused on camera-based methods (category c), where the goal is to optimize scene parameters (e.g., materials, textures, or geometry) [Gkioulekas et al. 2016[Gkioulekas et al. , 2013;;Khungurn et al. 2015;Li et al. 2018;Liu et al. 2018;Nimier-David et al. 2020, 2019;Zeltner et al. 2021;Zhang et al. 2019].These methods define an optimization objective on the difference between a rendered and a target image.
A strong focus has been on optimizing textures, while only few methods have considered optimizing light sources, which affect the result much more globally throughout the scene.Nimier-David et al. [2021] describe a texture-space sampling strategy to improve efficiency for multi-camera setups, while our approach removes cameras altogether.
Pioneering works in differentiable path tracing [Loubet et al. 2019;Nimier-David et al. 2019] have relied on code-level automatic differentiation (AD), recording a large computation graph, which is then traversed in reverse to compute the objective function gradient.However, AD fails for standard light tracing (Alg.1; also known as particle tracing), because each ray carries a constant amount of radiative flux (power) along the ray, independently of its direction or distance travelled.Consequently, parameters that affect these quantities (but not the per-ray flux) cannot be correctly differentiated with AD.The PSDR approach [Zhang et al. 2020] side-steps this issue by evaluating radiative transport in a path-space formulation before differentiation.One of our key insights is that we can take inspiration from their "material-form differential path integral" and construct a differentiation of light tracing itself for lighting parameters.Instead of using automatic differentiation, we formulate an analytical adjoint state per ray, which allows for an efficient GPU-based implementation.
The basic idea of adjoint methods is to reverse the flow of information through a simulation to find objective function gradients with respect to optimization parameters [Bradley 2019;Geilinger et al. 2020;Stam 2020].For path tracing, Mitsuba 3 [Jakob et al. 2022] provides a similar adjoint method, called "radiative backpropagation" [Nimier-David et al. 2020], which avoids the prohibitive memory cost of AD.They extend this approach to the reparameterized "path-replay backpropagation" integrator [Vicini et al. 2021].
In our view-independent case, we find that differentiable light tracing often outperforms path tracing in terms of optimization convergence behaviour (Fig. 2).Instead of transferring one radiance sample per path from a light source to a sensor, we update our radiance data at each ray-surface intersection and accordingly collect objective function derivatives from each of these locations in our adjoint tracing step, thereby using samples more efficiently.To our knowledge, we present the first view-independent, analytically differentiable light tracing, inverse rendering method.For comparisons to related work, we have implemented a reference differentiable path tracer working on our view-independent data structure.We also compare to existing image-based methods in a baseline test scenario, by restricting our objective function to consider only surfaces that are visible by their camera.In this way we separate the performance of the differentiation method from the benefits of operating on a larger global target.
One problem that has received a lot of attention recently is how to differentiate pixel values in the presence of discontinuous integrands due to silhouette edges or hard shadows.Various strategies to resolve these issues have been proposed, such as reparametrizing the discontinuous integrands [Loubet et al. 2019], repositioning the samples around discontinuous edges [Bangaru et al. 2020;Zeltner et al. 2021], or separating the affected integrals into interior and boundary terms and applying separate Monte-Carlo estimators to each part [Yan et al. 2022;Zhang et al. 2020].The main focus of these methods is to compute how a pixel value changes as a sharp edge or hard shadow moves within this pixel.Our light-tracing gradient formulation keeps ray-surface intersection points constant while moving light sources.Therefore, rays cannot move across feature edges when their source is perturbed, although lights could still move behind an occluding object.The resulting moving shadows are currently not explicitly handled in our formulation; we leave them for future work.Nevertheless, we achieve good optimization convergence using our gradients.While previous work often deals with situations where optimization parameters only affect a very small number of pixels, in our case, lighting parameters affect many receiving 3d surfaces simultaneously, thereby diminishing the relevance of shadows moving through a few surface elements, see also §6.4.Our comparisons show that Mitsuba 3's reparametrization method, and PSDR's edge sampling, resolve discontinuities but introduce noise, leading to reduced optimization convergence rates compared to their standard version.Using our spatio-directional data structure could in principle allow for extension of their code bases to the view-independent case, potentially including advanced discontinuity handling.For the specific case of lighting design optimization, however, our adjoint formulation is more efficient than these methods (even before considering the overhead of discontinuity handling), as shown in Fig. 11-13.

Lighting design
The problem of designing lighting configurations has also been previously explored in computer graphics and tackled from different perspectives.Many approaches use variations of the sketching metaphor, such as sketching the shape of shadows to indirectly move light sources [Poulin et al. 1997], or painting highlights and dark spots to control light parameters in the scene [Pellacini et al. 2007;Shesh and Chen 2007].Our view-independent differentiable rendering framework brings the sketching metaphor to 3d, providing a more intuitive way to paint the desired illumination directly into the scene.Therefore, the user-painted objective is guaranteed to be free of contradictions that might otherwise occur when editing images from different views corresponding to the same 3d location.
Procedural or hierarchical optimization approaches to luminaire placement have also been explored [Gkaravelis 2016;Jin and Lee 2019;Lin et al. 2013;Schwarz and Wonka 2014] As we focus on continuous optimization, these methods could be used to estimate a starting configuration before further optimizing the parameters of the generated light sources.
More recent approaches include the user in the optimization process [Sorger et al. 2016;Walch et al. 2019] directly, instead of automatically operating on a predefined target.These methods interactively display the current illumination and provide information about where and how this configuration could be improved.The user is then free to choose which measures to take in order to bring the scene closer to the desired state.In the future, our approach could be integrated into such a user-centred editing framework to improve the design interaction between the user and the optimization system.

PROBLEM STATEMENT
We start with the well-known rendering equation [Kajiya 1986], which models the exitant radiance (x,   ) from a point x on a surface in the outward direction   as The bidirectional reflectance distribution function (BRDF),  , encodes the material properties, and the incident radiance   (x,   ) at x is related to the radiance exitant from another point x ′ by   (x,   ) = (x ′ , −  ), such that x ′ is the nearest ray-surface intersection when tracing a ray from x in direction   .Here, we focus on reflective light transport for brevity, but in principle, transmissive surfaces could be included in mostly the same way.Consequently, we restrict the directional integration to the hemisphere H 2 instead of the entire (unit) sphere S 2 .We also do not consider any volumetric light-scattering effects.
We then minimize an objective function that measures the quality of a given lighting configuration.More formally, for this inverse rendering application, we consider objective functions  of the form (2) where  * is our illumination target,  is a user-defined weighting function, and (x,   ) must satisfy the rendering equation.As the emitted radiance   (p), due to a given set of light sources, depends on optimization parameters p, we look for local minima p * : p * = arg min p  ((p)), s.t. satisfies Eq. ( 1). (3) In order to address this problem, we compute an approximate solution, (x,   ), on the surfaces of a virtual 3d scene in a primal rendering pass ( §4.2).We then derive an adjoint (or backpropagation) rendering pass ( §4.3) that allows us to compute derivatives of the optimization objective with respect to the parameters, /p.Consequently, we are able to apply gradient-based continuous optimization methods to the lighting design problem.

VIEW-INDEPENDENT ADJOINT LIGHT TRACING
In the following sections, we first describe how we discretize the radiance data and optimization target ( §4.1), how we update this data while light tracing ( §4.2), and finally how we compute the objective gradient through adjoint light tracing ( §4.3).

Spatio-directional data structure
In order to represent the spatio-directional radiance field  with a finite number of variables (or degrees of freedom, DOF), we first construct an appropriate interpolation scheme.We then use this scheme to find approximate solutions to Eq. (1).
For the spatial component, we choose a piece-wise linear interpolation, as often used in finite element (and specifically radiosity) methods [Greenberg et al. 1986;Larson and Bengzon 2013]: Instead of single nodal values, however, we consider   to be a directional function associated with the -th mesh vertex and its nodal basis function   .
For the directional component, we discretize each per-vertex function   (  ) using a hemi-spherical harmonic (HSH) basis [Gautron et al. 2004;Green 2003;Krivanek et al. 2005;Sillion et al. 1991], specifically, the 2-normalized hemi-spherical harmonics    [Wieczorek and Meschede 2018].Each directional function is consequently represented as where  is the maximal order used in this approximation, which implies that for each vertex , we require ( + 1) 2 directional coefficients.Consequently, our spatio-directional approximation (using three colour channels, RGB) has 3( + 1) 2 degrees of freedom, where  is the number of mesh vertices.
For completeness, we summarize the construction of    in the supplementary material.Furthermore, for the special case  = 0, which is sufficient for diffuse surfaces, we effectively ignore the directional component and simply store vertex colours.Note that even if we choose  = 0, our light tracing method may still include glossy materials when simulating indirect lighting.
Our primary goal is to solve inverse problems based on this discretization, whereas we produce high-quality output images via standard rendering methods.Therefore, we favour the simplicity of this discretization over alternatives such as texture-like bilinear interpolation or meshless bases [Lehtinen et al. 2008].In contrast to previous work, we store exitant rather than incident radiance.We also define our optimization objective on the exitant radiance, which can be intuitively painted by the user (Fig. 4).Discretizing the target radiance field  * (x,   ) using the projection derived in the supplement, yields target coefficients  *  and subsequently a discrete analog of the objective function, Eq. ( 2): where   is the area associated with vertex , i.e, one third of the sum of adjacent triangle areas.Here, we use a shorthand notation for the nested summation over vertices and HSH coefficients according to Eq. ( 4) and ( 5).We choose to split the weights into a spatial and a directional component,   and   respectively.Thus, the weights   adjust the influence of each HSH band: over-weighting lower bands for example would emphasize low-frequency components of the reflected radiance.Similarly,   allows us to focus the attention of the optimizer on specific parts of the scene geometry.We use a painting interface to allow the user to specify  *  as well as   .The HSH coefficients can be efficiently painted using a "directional" brush combined with an angular blur kernel, which is easy to compute because a closed-form solution to Laplacian smoothing exists in HSH space.
For differentiable rendering, note that the derivative of Eq. ( 6), /  is straightforward to evaluate, which we use in §4.3.

Primal light tracing
One key feature of our discretization is the orthogonality of all basis functions.Therefore, we can project each radiance sample computed during light tracing into our data structure quickly and independently.In this section, we discuss how we solve the rendering equation using light tracing and update the coefficients {  } of our data structure accordingly.We summarize this procedure in Alg. 1, and provide a detailed derivation in the supplementary document.
Theoretically, we could regard our data structure as a generalized sensor and construct a path-space formulation of its measurement integral.Here, we instead consider light transport in the simpler particle tracing form, directly discretizing each light source's radiative power into a set of light rays.In §4.4 we then use ideas from the path-space theory to formulate the required derivatives for our light tracing approach.For every light source, we sample  exitant rays, each representing a radiant flux Φ  leaving the light source, distributed according to the light's emission profile, such that the sum of all these exitant samples equals the total radiative power of the light.Let x 0 be the origin of a ray.We then construct a light path up to a maximal number of indirect bounces, denoted as a sequence of ray-surface intersection points x 1 , . . ., x  , . . ., x max .8) Exitant ray: (indirect illumination), where   denotes the BRDF evaluated at x  , n  is the surface normal at x  and  +1 is the probability density of the exitant sample in direction At every intersection point x  , we sample the exitant radiance distribution due to the incident flux Φ  along  ′ randomly selected outward directions   .We then update the coefficients {  }, by adding the contribution of each sample   to each vertex , adjacent to x  , as follows: where  refers to the vertices of the triangle containing x  , with vertex-associated area   , while  and  refer to each HSH basis function up to the selected maximal order .Please refer to our supplement for a detailed derivation of this update rule.

Adjoint Primal
Local Sample Distribute L Gather ∂O/∂L Light Path Fig. 5. Illustration of our primal and adjoint light tracing approach.In the primal pass, we trace radiant flux into the scene, while in the adjoint pass we collect derivatives of the objective function along the light path.

Adjoint light tracing
So far we have discussed how we store the exitant radiance field ( §4.1) and how each light path affects the degrees of freedom of this field ( §4.2).We now turn our attention to improving the lighting configuration of a scene via gradient-based optimization and an adjoint formulation for computing the required gradients.
In contrast to previous work on image-based differentiable rendering, we do not handle derivatives along discontinuous edges in our method.This means we primarily ignore direct shadows, and instead focus on an efficient derivative formulation for the continuous case.Our results show that these discontinuity problems have limited influence in common lighting design tasks; even in specifically designed test cases (Fig. 20 & 21), the optimization algorithm sometimes recovers from receiving these biased gradients.
In the context of our light tracer, parameters that affect the lighting configuration may cause changes in brightness or colour (Φ  ), as well as the ray origin, x 0 .In case the origin shifts (infinitesimally), the question is how this change propagates through the scene.Does the first hit, x 1 , also shift, and if so, what about the rest of the light path, x  ?Automatic differentiation of Alg. 1 would answer "yes" and compute derivatives of all hit points, x  /x 0 , as well as derivatives of the interpolation basis functions.Our test cases (Fig. 6 & 7) show that this naïve approach does not lead to useful results.Zhang et al. [2020] (PSDR) work around this issue by moving the evaluation to path space before applying AD.Following a similar idea, we compute derivatives by treating the light path {x  } as a parameterindependent constant sample in path space when computing derivatives.Consequently, if a light source moves, only the origin, x 0 , and hence the first incident direction,  1 = (x 1 − x 0 )/∥x 1 − x 0 ∥, are parameter dependent.All other intersection points, x  , remain fixed to the scene geometry.We first derive the general structure of our adjoint tracing method in this section, and then compute the required parametric derivatives in §4.4.
Our goal is to compute the objective function gradient with respect to the parameters p, which affect the solution   (p): The partial derivative /  can be interpreted as the desired illumination change in the 3d scene per degree of freedom of the discretized radiance field.We first consider the direct differentiation for   /p and then re-arrange the resulting terms to formulate an adjoint state per light path.Every light path resulting from a primary light ray  affects some coefficients of the solution   according to Eq. ( 8).Consequently, we can split the sensitivity term   /p into contributions per path as follows: Note that for direct illumination, the direct incident flux Φ 1 does not depend on the BRDF  1 , therefore the second term vanishes  12) and Eq. ( 13) Exitant ray: Finally, update gradient according to Eq. ( 11).
when  = 1, as Φ 1 / 1 = 0. Similarly, only  1 depends on the direct incident angle  1 , but later BRDF evaluations do not, therefore, the third term vanishes for indirect illumination, because   / 1 = 0 for  > 1.While we have omitted function arguments for brevity, it is important to point out that the direct BRDF is sampled along local outward directions   , see Eq. ( 8), whereas the indirect path evaluates the BRDF towards the exitant direction of the first bounce,  2 , Eq. ( 7).Both of these terms depend on the first incident direction  1 , which changes when the origin of the light path moves.This dependence is stated explicitly in Eq. ( 10); in the following we use the notation   1 ( 2 )/p and   1 (  )/p to distinguish these terms.
Storing the full sensitivity matrix   /p =  (  /p)  by summation over contributions from all paths, Eq. ( 10), would consume a lot of memory as the number of parameters grows.Our formulation avoids this memory cost and instead uses adjoint states per path, which fit into the local memory of each GPU thread.
Instead of tracing derivatives of radiant flux forward along a light path, we collect partial objective derivatives backwards along that path and compute a weighted sum of partial derivatives /Φ  .Nimier-David et al.
[2020] also refer to a similar quantity as adjoint radiance in their work.Their concept of adjoint radiance projects partial derivatives of the objective function from an image into the scene along camera paths, whereas we collect objective derivatives along light paths.Combining Eq. ( 9) and (10), including summation over light paths noted above, and then re-arranging terms, yields: (11) Here, /Φ  and / 1 ( 2 ), are adjoint states, collecting objective function derivatives along the light path.We update these terms at every ray-surface intersection point x  , analogous to the primal simulation, Eq. ( 8): and Figure 5 illustrates this idea, which we also outline in Alg. 2. Furthermore, the derivative wrt. the BRDF under direct illumination, / 1 (  ), only occurs at x 1 and can be calculated directly from Eq. ( 8) and ( 6).Similarly, the derivative of the BRDF itself wrt.parameters p follows directly from the BRDF's definition.Additionally, we find the derivative terms required to evaluate Eq. ( 12) and ( 13) as follows: /  is the derivative of Eq. ( 6), while   /Φ  follows from differentiating Eq. ( 8).Finally, Φ  /Φ  and Φ  / 1 ( 2 ) are tracked along the light path, effectively expanding the recursive product induced by Eq. ( 7) and collecting factors.
Note that in our formulation, primal and adjoint tracing are entirely separate rendering passes.In contrast, automatic differentiation correlates primal rendering and derivative calculation, and previous methods work around this issue by running the primal pass twice ("decorrelation").Here, whether we evaluate the adjoint step in a correlated or decorrelated way is simply a question of whether we choose the same or a different random seed compared to the primal step.In validation tests and finite difference comparisons, we use the correlated evaluation (i.e., keeping the same random seed in all rendering passes), while for all other results we use decorrelated evaluation.

Optimization parameters
The final step to evaluating the objective function gradient according to Eq. ( 11) is computing Φ  /p for all parameters p of the lighting configuration.Note that this is the only term that depends on the type of each light source (point, spot, area, etc.) and on the meaning of each parameter (position, intensity, rotation, etc.).As Φ  denotes the direct illumination, these derivatives can generally be calculated analytically, and we briefly summarize them here, while deferring details to the supplementary document.
4.4.1 Intensity and colour.Intensity (per colour channel)   for point-shaped lights (or analogously emissive power for area lights) directly affects the emitted flux per light ray, hence the corresponding derivative is straightforward to calculate.We find it useful to parametrize intensity with a quadratic function,   = 0.5p 2  , where p  is the corresponding optimization parameter, to prevent negative values.If the task is to optimize chromaticity, but maintain a constant intensity, we need to find a colour vector c = (, , ) such that  +  +  = 1.We implement this constraint by projecting c to c  = c/( + +) in each optimization step, and similarly projecting the derivative by multiplying with the Jacobian (c  /c).

Position and rotation.
Let us now consider the derivative of the objective function with respect to a light's position /x.As discussed in §4.3, the naïve approach would compute the set of spatial derivatives x  /x for the entire path.Automatic differentiation also produces this result, see Mitsuba 3's 'ptracer' in Fig. 11 and 12.

1%
Our gradient Naïve gradient Fig. 6.Validation of our gradient formulation using finite difference approximations at various step sizes (for the light's 3d position in Fig. 14a).Our gradient closely matches FD approximations at adequate step sizes and we observe the expected trade-off between floating-point errors (too small FD steps) and approximation errors (too large FD steps).The naïve version, however, exhibits large systematic errors across a wide range of step sizes.
There is, however, a serious issue with this naïve approach: computing derivatives in this way generally fails to produce reliable descent directions that would be useful for gradient-based optimization of lighting configurations, Fig. 7.This issue arises because any spatial derivative of x  results in a vector in the plane of the triangle containing x  , with discontinuous jumps between triangles, as illustrated in the inset of Fig. 7.Note that this type of discontinuity problem is distinct from the case of moving hard shadows due to occlusions (we intentionally ignore the latter).The former issue, however, causes severe limitations for differentiable light (or particle) tracing and must be addressed.
The PSDR approach [Zhang et al. 2020] avoids this issue by evaluating the entire path according to the path-integral formulation (including all geometric terms explicitly) and then applying automatic differentiation.In contrast to their general formulation, we deal specifically with parameters that affect light sources, which means that we only need to consider the first geometric term, while our adjoint states handle the indirect light path.For the remaining direct part, we now apply a similar idea in explicitly differentiating the geometric term at x 1 .For improved performance, we compute these derivatives analytically, rather than relying on code-level AD.The resulting expressions fit into thread-local GPU memory allowing for efficient parallel computation.
Our solution to finding useful gradients wrt.position and rotation of a light source is to consider the "reverse" direction of the primary light ray (x 0 → x 1 ) as if we were tracing the ray in the other direction (via next event estimation from the scene geometry to the light source).Consequently, we treat x 1 as constant, while the light source moves (or rotates) and consider a "virtual" intensity per ray, Ĩ = Φ   2 /( 1 • n), representing the irradiance this ray transports from the light source to x 1 .The direct illumination due to Φ  behaves like Ĩ ( 1 • n)/ 2 locally.Consequently, the derivative of the incident flux with respect to the light's position becomes We compute this derivative using symbolic math software, as shown in our supplementary document.Figure 6 compares errors of our gradient to the naïve version discussed earlier, relative to finite difference (FD) approximations of various step sizes.As expected, for small step sizes finite differencing suffers from floating-point errors, whereas for large step sizes, FD approximation error dominates.For a suitable range of step sizes, our gradients agree well with finite difference approximations.The naïve approach, on the other hand, shows systematic error over a wide range of FD step sizes.This error accumulates during the summation over many rays; for single light paths, we have verified the correct implementation of the naïve gradient calculation.In Fig. 7 we compare our improved approach to the naïve version on the basic optimization task of positioning a spot light.Using our method, gradient descent optimization converges quickly, and reliably remains in the optimal configuration.We intentionally choose a standard gradient descent approach (i.e., updating x ← x −  (/x)) instead of more elaborate optimization algorithms for this example, because it most clearly exposes the flaws of the naïve differentiation approach.
Moving on to rotations, we parametrize the orientation of light sources by a rotation vector  , which defines a rotation matrix R( ) following Rodrigues' formula.The world-space orientation (normal n and tangent t) results from applying this rotation to the materialspace normal and tangent (n 0 , t 0 ) respectively.We use the linear small-angle approximation to avoid numerical issues when ∥ ∥ approaches zero.Applying the chain rule, we find the derivative of the flux wrt. the rotation vector: where we compute the terms n/ and t/ using symbolic differentiation of Rodrigues' formula.Finally, we find Φ  /n and Φ  /t via symbolic differentiation, again keeping x 1 fixed.The exact expressions depend on the type of light source.For instance, IES data files [ANSI/IES 2020]-which are widely used in architecture-define the emitted intensity by tabulated values, interpolated bilinearly over the unit sphere; spot lights with soft edges use a quadratic attenuation profile between the inner and outer cone angle; whereas area light sources assume a cosine-weighted emission profile.Please refer to our supplementary document for further details.Note that for area lights the ray origin moves when the light is rotated, i.e., x 0 ( ).(For our purposes we only consider rigid rotation and translation.)In this case, the derivatives wrt. the light's orientation include an additional term, analogous to Eq. ( 14) to account for the shift of the ray origin, as described in the supplement.and then continues bouncing through the scene.Evaluating Eq. ( 11) restricted to these paths, we find contributions to the derivative /p  that "flow" through the point q.Intuitively, we can think of each point q casting a vote on how the parameter p  should change in order to improve the objective function (while taking indirect reflections from q into account).Note that this quantity is different from adjoint radiance [Nimier-David et al. 2020], which does not include derivatives wrt.parameters, or indirect bounces.
The example in Fig. 8 shows which parts of the dragon would improve the objective function if the light moves right (red) or left (blue).The final objective function gradient /p can be thought of as the sum of these contributions.We compare our visualization to a reference implementation that directly differentiates the radiance field and a finite difference approximation in Fig. 8, and also to related work in Fig. 12.For (mostly) direct lighting, our method and the reference yield nearly identical results; when the objective is strongly influenced by indirect illumination, however, our adjoint visualization draws gradient contributions at the first ray-surface intersection, whereas direct differentiation produces a response at the target surface instead (see the additional example in our supplement).

RESULTS
In this section we first cover verification test cases, as well as comparisons to related methods; we then demonstrate the ability of our Note that Mitsuba's 'prb_reparam' method eventually converges (around 150 iterations), whereas their 'ptracer' does not.The graph on the right shows the total runtime for 100 iterations: our light tracer is ca.twice as fast as our reference path tracer, while comparing the three Mitsuba integrators shows the runtime impact of discontinuity handling.
approach to address creative lighting design cases.Unless stated otherwise, we trace two indirect bounces in all of our results.Our light transport simulations run on the GPU, specifically a NVIDIA GeForce RTX 3080, using hardware-accelerated ray tracing via the Vulkan API.We also evaluate the objective function on the GPU, but transfer the optimization parameters and their derivatives to the CPU, in order to access publicly available optimization libraries.Running the optimization algorithm on the CPU is not a performance bottleneck, as the size of the parameter vector is much smaller than the size of the radiance data.
In general, predicting which optimization algorithm will perform best for a specific task is difficult.In our results we demonstrate that we provide gradient information that works with multiple commonly used optimization methods, most notably gradient descent, ADAM, and L-BFGS [Nocedal 1980].Our implementation uses the LBFGS++ library [2021], as well as the ADAM algorithm of Kingma and Ba [2014] (using decay rates  1 = 0.9 and  2 = 0.999 as suggested in the original publication for all our results).For comparisons to gradient-free CMA-ES, we use the code by Hansen [2021;2003].

Verification tests
We first verify that our differentiable light-tracing system is capable of solving various inverse problems, where a well-defined solution exists.We perform ground-truth recovery tests, where the illumination target is copied from the result corresponding to a specific lighting configuration in various scenes: a large office (Fig. 1), a glossy coin, using hemi-spherical harmonics up to order  = 5 (Fig. 9), as well as the Stanford bunny (Fig. 11).For these examples, we visualize the differences to the ground-truth target before and after optimization, or compare convergence of the optimization to related methods (see details in §6.2).
Apart from ground-truth tests, we verify that our method correctly finds solutions for well-defined objectives on specific surfaces, Fig. 7 and Fig. 10, and compare our gradient calculation to finite difference approximations in Fig. 6, Fig. 8, and Fig. 14.In our supplementary material we also provide a visual comparison of different orders of HSH interpolation, which shows that our radiance data structure converges under refinement.
Finally, we test the capabilities of our system in dealing with indirect illumination.In Fig. 10, we place a spot light into a small "labyrinth", such that light can only reach the "exit" via multiple bounces.The side walls of the labyrinth have a dark target value to push the light away from the walls, with a very low weight (  = 0.004), whereas the exit has a very bright target with unit weight to attract the light source.We trace light paths with 10 indirect bounces in this example.Optimizing for position and rotation simultaneously using ADAM with step size  = 0.2 successfully navigates the light through the labyrinth in ca. 10 s and 200 gradient evaluations.In principle, L-BFGS also successfully solves this problem, but the momentum estimated by ADAM results in a smoother, visually appealing motion of the light source.

Comparison to previous work
Current work on inverse rendering always considers images to define the optimization objective.We establish a baseline for comparing our (camera-free) view-independent approach to existing methods by restricting our objective function to data available to imagebased methods (camera-visible surfaces) on a test scene, where one camera sufficiently captures most surfaces (except of course the back of the bunny, Fig. 12).In this test, we use ideally diffuse materials for all objects in the scene, and no directional data ( = 0) for our light tracer and reference path tracer, to allow for a fair comparison.As shown in Fig. 11, our adjoint light tracing matches state-of-the-art methods in this setting in terms of optimization convergence, while our adjoint formulation, combined with an efficient GPU-based implementation outperforms other methods in terms of runtime.We use an equal number of samples for these comparisons.Finally, note that for the unrestricted case ('full') with  = 0, Fig. 11 also contains an "object-space" baseline comparison between our light tracer and reference path tracer, which shows that light tracing (0.38 ) outperforms path tracing (0.9 ) for an equal number of samples (delivering equal optimization convergence).
Mitsuba's light tracing method ('ptracer'), using automatic differentiation, fails to converge, similar to our naïve differentiation approach in Fig. 7.The differentiable path-integral formulation of PSDR 1 [Zhang et al. 2020], on the other hand, produces good results in this simple setting for both light and path tracing (with slightly more noise and reduced convergence rate of their light tracer).
While related image-based methods (Mitsuba, PSDR) handle discontinous edges in various ways, they also introduce additional noise into the gradient (compared to Mitsuba's standard AD path 1 Most features of the PSDR code are currently only available in their CPU-based implementation.PSDR currently only supports area lights, but neither point, spot, nor IES lights. .Each image uses 16 million primary samples, additional samples for discontinuity handling are stated per image as applicable.Note that Mitsuba 3's particle tracer fails to produce correct results.PSDR's path-space approach works, but light tracing causes more noise than their path tracer.Our gradient calculations ignore the moving shadow (bottom left corner), but produce comparable results to Mitsuba's standard path tracer.In particular, our adjoint light tracing produces equally clean results, while other light tracers are noticeably noisier.
tracer), causing reduced optimization convergence (Fig. 11).As discontinuity handling also comes with a runtime cost, we choose speed over (theoretical) accuracy for the scope of this paper; we analyze the effects of the resulting gradient bias in §6.4.Overall, our approach produces less noisy gradient data compared to existing differentiable light tracing methods.
For further comparison, we also implement a reference differentiable path tracer following the ideas of Stam [2020] on top of our view-independent data structure: we uniformly sample each triangle and trace paths with next event estimation to find the incident radiance.Finally, we sample exitant directions locally, apply the BRDF and update our data structure according to Eq. ( 8).This path tracer uses the same sampling strategies to construct indirect illumination paths as our light tracer for a fair comparison of our light tracing method against "object-space" path tracing.The gradients produced by this path tracer closely match Mitsuba's AD path tracer (Fig. 12).For the baseline test scene we observe similar convergence behaviour between restricted objective function data and full view-independent data (i.e., camera-visible vs. all surfaces in the scene), as intended, while our light-tracing approach is substantially faster than path tracing.We show an extension of this baseline test in the supplement, where adding an off-camera box around the scene highlights the advantage of our view-independent approach.Furthermore, Fig. 15 shows an equal-time comparison on the more complex optimization problem in Fig. 14, where our light-tracing method yields improved convergence rates, due to reduced (gradient) noise (similar behaviour is also visible in Fig. 2, as well as the indirect illumination "labyrinth" example in our video).Finally, we compare our approach to Mitsuba 3 on a large office scene (Fig. 13), where Mitsuba uses four cameras to cover most of the scene.We again restrict our method to surfaces visible by any camera for comparison (Fig. 13).Mitsuba's reparmetrization shows reduced optimization performance (likely due to increased noise Our gradient FD gradient Fig. 14.A basic lighting design case: the target requires the tables (dashed lines in a) to be lit uniformly (the rest of the scene does not affect the objective   = 0).We plot the objective function on a regular grid in the horizontal plane (a), where the orange dot marks the initial position of the light source, producing the rendered result in the background.Arrows show negative gradients wrt. the in-plane position of the light, which reliably point towards a local minimum.We visually compare these gradients to a finite difference approximation (b).Initial and optimal light position overlaid on the final illumination (d): the light becomes brighter and moves centrally over the tables during optimization.We compare convergence of gradient descent and L-BFGS (both using our gradients) to gradient-free CMA-ES optimization (c).With each method, we first optimize only the light's 3d position (solid lines) and then its position and intensity combined (dashed lines).Fig. 15.Equal-time comparison between our adjoint light tracing and our reference differentiable path tracing implementation on the combined optimization of the light source's position and intensity, as in Fig. 14.Using our gradients, both gradient descent (step size  = 0.1) and L-BFGS converge robustly, whereas differentiable path tracing produces more noisy gradients, preventing convergence.(Note that we squeeze the x-axis between iterations 150 − 450 to show the later gradient descent iterations.L-BFGS, on the other hand, terminates when it fails to find an improved configuration.) in the gradient estimates).Using our method without restriction to visible surface improves convergence, even at lower sample count.This behaviour is due to the global coupling between parameters in the lighting design problem, which is in this sense a more challenging optimization problem than, for instance, optimizing texture colours given a target image.In summary, in terms of optimization convergence, our adjoint light tracing method at least matches, and on complex scenes outperforms, state-of-the art inverse rendering systems on the lighting design problem.Our formulation enables a fast GPU implementation, which results in far better runtime performance.

Lighting design applications
6.3.1 Small office lighting.We first show an example of a fully automatic optimization of a single point light in a small office scene, Fig. 14.The optimization target specifies bright, but uniform lighting on the top surface of both tables, a common regulatory requirement for work spaces.In the initial configuration, a point light is placed off to one side, causing the work space to be too dimly and unevenly lit.We test different optimization methods on two subsequent tasks in this scene: the first optimizes the 3d position of the light, placing it centrally above the tables for a good trade-off between brightness and uniformity; the second jointly optimizes for the light's intensity and position.The optimal light placement is now just underneath the ceiling (thereby improving uniformity), with the intensity increased to compensate for the larger distance (Fig. 14d).
We compare the performance of GD and L-BFGS to gradient-free CMA-ES [Hansen et al. 2003] in Fig. 14c.In the first, position-only, optimization task, both L-BFGS and GD reliably find a good solution in 6.5  and 42 objective and gradient evaluations, or 7.9  and 52 evaluations respectively.In comparison, CMA-ES requires around 200 objective evaluations to find a good solution (initial standard deviation  = 1 for all parameters).In general, the computation time required to evaluate gradients via an adjoint method is close to the time needed to compute the solution itself.Therefore, even though CMA-ES does not need to evaluate gradients, the total runtime is still significantly slower than gradient-based methods.See also Table 1 for timings of the primal and adjoint evaluations in our examples.In the second task, when we optimize for position and intensity simultaneously, the Hessian approximation built by the L-BFGS method captures the relation between the height (distance) and intensity.Consequently, L-BFGS finds a good solution (Fig. 14) in 8.2  and 45 evaluations.Plain gradient descent and ADAM (as shown in our video), on the other hand, converge more slowly, while CMA finds an acceptable solution after about 400 evaluations.
6.3.2Directional lighting of a glossy coin.In Fig. 17 we show an example where directional lighting plays an important role.The user specifies a direction-dependent target by painting directly into the HSH-discretized data structure and coefficients  *  .In this example, we set the per-channel weights   such as to under-weight the undirected lighting component represented by  0 0 by a factor of 0.1 relative to the directional components of the radiance data.Using our adjoint gradients, an L-BFGS optimizer successfully navigates the light source around the coin to find the best matching directional lighting configuration.
6.3.3Real-world bust of David.We demonstrate the applicability of our system to an artistic lighting design process on a small bust of David figurine, Fig. 16.We first laser-scan the bust and build a 3d mesh suitable for our simulation using a Metris MCA 3600 articulated arm with a Metris MMD 50 laser scanner.In our interactive user interface, we then sketch a desired shading onto this model.Performing 100 iterations of ADAM optimization ( = 0.14), which takes about 7.5 s, we find the position and orientation of a spot light that closely matches the painted target.In order to validate our result, we replicate this lighting configuration on the real-life specimen, Fig. 16f.We use a Cree® XLamp® CXA1304 LED and a custom-made snout to limit the cone angle to 45°, matching our simulation.We apply only basic white balance and gradation curve adjustments to the real-world photographs.
6.3.4Refurbishing baked lighting.Another interesting application of our system is "refurbishing" old video games.In many cases, the diffuse (potentially also indirect) illumination is baked into static lightmaps.However, all information about the original light sources, which would be required to render the scenes with a modern realtime ray tracing method, is often lost.Here, we reconstruct light sources such that the given textures (assumed to represent albedo), combined with the recovered lighting produce a similar impression as the original game.We demonstrate this approach in Fig. 18, where we build lighting configurations for two different scenes from OpenArena [2008].In each case, we first initialize a regular grid (e.g., 9 × 9 × 2) of low-intensity point lights, covering the bounding box of the scene.We then optimize for position, colour, and intensity of all lights simultaneously (up to 972 parameters) using ADAM.Figure 18 shows overviews of the initial and final lighting configuration, and interior views of our results.
6.3.5 Large office.In a more complex example, we show a lighting optimization of a large office consisting of two floors.This scene is illuminated by two point lights (one over the staircase, one over the lounge area), two spot lights near the reception and statue, an area light over the conference table, and two highly anisotropic lights (using IES intensity profiles [ANSI/IES 2020]) on the top floor.We first show a result that recovers a given ground-truth (Fig. 1) and compare the optimization convergence to our reference path tracer (Fig. 2).We also compare our method to Mitsuba 3 on this scene (replacing the IES lights, which are not supported by Mitsuba, with spot lights) in §6.2.We then demonstrate the ability of our system to interactively edit the desired illumination and automatically reconfigure the lighting design accordingly in Fig. 4.
6.3.6 Theatre stage lighting.Finally, we show an interactive design session, where the user starts from a completely unlit scene and iteratively adds light sources, selects optimization parameters, and updates the illumination target.The interactive workflow alternates between user manipulations and automatic lighting optimization to realize the intended design, as shown in our video.Figure 19 summarizes the result of this design example.In total, this lighting design session required about 10 minutes to complete, with just over 2 minutes spent on automatic design optimization, and the remaining time on various user interactions including visual inspection of the results.Please also refer to Table 1 for a performance overview of our results.

Discontinuity Failure Cases
In this section, we analyze specific situations where our method may fail to converge properly due to not handling occlusion discontinuities (moving shadows).First, we show a modified lighting design example in Fig. 20, where the optimizer should navigate the light (in the horizontal plane) in between the occluding panels on the ceiling of a small office.In a second test case, we construct a scene exhibiting a high degree of occlusion, Fig. 21, where the light must move through a staggered array of cubes.In both cases, we clearly observe that our gradients are lacking information about how the moving occlusion boundaries (shadows) affect the objective function, causing most optimization attempts to fail.Especially gradient descent or L-BFGS exhibit convergence problems in these tests, as they rely on being provided with a valid descent direction.Adding momentum, as in ADAM, on the other hand, can sometimes recover and "skip over" areas exposed to problematic gradients.In fortunate cases, where momentum compensates for gradient bias, ADAM sometimes finds acceptable solutions, even with inaccurate gradient data.
One additional problem caused by noisy or wrong gradients is the increased chance of a light entering a closed-off scene object, effectively trapping it and stalling optimization.Note, however, that lights passing through a wall cause a truly non-differentiable discontinuity that could still occur even with known discontinuity handling methods and should be addressed by continuous collision detection instead.We leave this line of investigation for future work.

LIMITATIONS AND FUTURE WORK
We focus on continuous optimization of a given lighting configuration, relying on the user to provide an initial placement of light sources, either interactively or as part of the original scene description.In the future we will investigate extending our method with mixed-integer optimization approaches to also optimize for noncontinuous parameters like the selection of light sources.Currently, we do not handle discontinuities due to moving shadows in our derivatives, which has been done in previous work on camera-based differentiable rendering.Because our lighting objectives measure relatively large areas and our radiance solution is continuously interpolated, our method converges robustly nonetheless.In the future, it will be interesting to investigate discontinuity handling for specific applications, such as lampshade design, that rely on accurately placing an occluding object in front of a light source.In our implementation, we do not employ advanced sampling strategies, like importance sampling, which are often used to increase the efficiency of Monte Carlo methods.Such methods have recently been successfully applied to differentiable image rendering.As the resulting methods may require parameter-dependent sampling, thereby complicating the calculation of derivatives, we leave this line of research in the context of our light-tracing approach for future work.Similarly, we currently use a user-defined number of HSH basis functions to represent the directional component of the radiance field.In the future it could be interesting to investigate choosing the interpolation order adaptively based on the material properties and lighting conditions.

CONCLUSION
In summary, our method enables lighting optimization via differentiable rendering, for the first time providing two important features: interactive feedback and easily modifiable, view-independent objectives.We present a novel, analytical adjoint light-tracing formulation, rather than relying on automatic differentiation.Our view-independent radiance data structure can be quickly updated, both during light tracing and while painting illumination targets.
Combining our adjoint formulation and data structure yields an efficient implementation, which improves per-iteration runtime (equal samples) and convergence rates, compared to existing methods.
Providing objective function values and gradients in each iteration allows us to use any first-order optimizer in a black-box fashion.Note that we do not use interpolation-basis-function derivatives in our approach, therefore gradient accuracy does not suffer due to low quality meshes.
Our validation tests show that differentiating the incident flux, while keeping the first ray-surface intersection point constant, captures gradients of information that is contained in the distribution of discrete light rays.Our method computes more accurate gradients compared to a naïve approach as evidenced by finite difference and optimization convergence tests.We also show that (in equal time comparisons) adjoint light tracing results in improved optimization convergence behaviour than differentiable path tracing, and that our method outperforms existing image-based differentiable rendering methods on a baseline test scene.We also provide a novel visualization of adjoint gradient contributions to analyze the composition of the objective function gradient.Furthermore, we show the applicability of our system to various lighting design tasks that cannot be easily handled by state-of-the-art image-based inverse rendering, including large-scale work spaces, artistic installations, and video game refurbishing.where we compute both the derivative of the bi-linear interpolation,   /(, ), and the polar coordinates,  (, )/x, using symbolic code generation.Similarly, the terms required to evaluate Eq. ( 15) are for the normal n, and analogously for the tangent t.
Finally, for area lights, we assume that the emission follows a cosine-shaped profile and does not vary across the light's surface.For convenience, we also scale by the surface area , so that the total emitted power remains constant when changing the light's shape.Hence the emitted radiance is   cos( )/ at every point on the surface, where  is the angle between the light's surface normal n and the exitant ray direction  1 .For simplicity, we only consider planar, rectangular light shapes in this work.We again trace  exitant rays, sampled uniformly over the surface and hemisphere, with exitant flux Φ  =    ( )/ .and again analogously for the light's tangent vector.Here, we compute the derivative of cos  1 / 2 wrt. the light's orientation by keeping the ray-surface intersection x 1 constant, while the ray origin x 0 rotates about the light's centroid x such that it's coordinates in the local frame of reference defined by (n, t) remain unchanged.
Recall that  1 is the direction, and  the distance, from x 0 to x 1 .We again compute the derivative of this transformation by symbolic differentiation and automatic code generation.

Further gradient comparison
In Fig. S2 we extend the comparison in §6.2 of our adjoint light tracing to a reference differentiable path tracing implementation that also uses our view-independent data structure to deliver the rendered radiance field and evaluate the same objective function.
For a comparison that is indicative of optimization performance, we choose a new arbitrary random seed for each evaluation during finite difference approximation.In this way, the finite difference errors reveal that the path tracing approach produces less accurate gradients (due to sampling noise) in an equal time comparison to our method.Note that choosing new random seeds is more applicable in an optimization context, where we want sampling noise to average out over the course of the optimization procedure, rather than optimize for a specific noise pattern.

Extended baseline comparison
In our baseline test case (Fig. 11) we intentionally avoid most global influences caused by indirect illumination.As expected, our novel view-independent approach performs comparable to state-of-theart image-based methods, regardless of whether we restrict our method to camera-visible surfaces, or evaluate the entire scene.In Fig. S3, we now extend the test scene by adding a box around all other objects, which increases the contribution of indirect illumination to the bunny and the background plane.Mitsuba's path tracer (without discontinuity handling), as well as our method when using restricted data for comparison, now converge slightly slower than in the original case (without the box), showing that the optimization problem becomes more challenging due to indirect illumination.PSDR (including discontinuity handling) now matches the convergence of these methods (having been worse before), showing that the additional indirect illumination reduces the influence of the discontinuous gradient contributions.Finally, using our method and the full radiance data (including the box) as a target, improves the convergence rate by roughly 50%, demonstrating the advantage of a view-independent approach.When completing the entire optimization (100 iterations), our method is about 3× faster than Mitsuba's path tracer on this scene.Conversely, for image-based methods we would need to introduce additional cameras that cover the new surfaces of the box to achieve a similar effect.Table S1 gives an overview of all methods used and summarizes their features.

Gradient contribution visualization
In this section, we show extended comparisons for our gradient contribution visualization introduced in §5.We first expand Fig. 8 with additional comparisons showing all three light position coordinates in Fig. S5.We again show results for finite differencing (Δ/Δp), direct (i.e.non-adjoint) differentiation (/p), and our adjoint state (/Φ  ).
We then show an additional visualization example, Fig. S4 for an intermediate lighting configuration that occurs during the optimization shown in Fig. 10.At this point, the spot light has not navigated around the final corner in the labyrinth, so the target is still only illuminated by indirect light.In this situation, the difference between our adjoint approach, and a direct differentiation method (akin to forward-mode autodiff) is most clearly visible.Direct differentiation produces a similar result as a finite difference approximation, visualizing contributions to the objective function gradient at the target surface (after indirect light arrives there).Our approach, on the other hand, transports information about objective function derivatives backwards along light paths and visualizes the resulting gradient contribution at the first ray-surface intersection along these paths.In this way, we can observe how (indirect) light paths passing through parts of the surface near the light source contribute to the objective gradient at the target surface.Note that the objective gradient (which is integrated over all such contributions on surfaces) still pulls the light left towards the target.

Fig. 2 .
Fig. 2. Comparing light tracing to path tracing on a large scene using our radiance data structure: While path tracing (a) would need more advanced sampling strategies to deal with a large non-uniform mesh, light tracing (b) naturally focuses samples on brighter areas, leading to a less noisy result and therefore improved optimization convergence (c) at equal runtime.

Fig. 3 .
Fig.3.Illustration of our adjoint light-tracing optimization.See also Fig.5for further details on the primal and adjoint data flow.

Fig. 4 .
Fig. 4. Iterative refinement of the scene shown in Fig. 1.First, desired changes are sketched on the 3d geometry (left), the optimization then adjusts the nearest light's position accordingly (right).

Algorithm 1
Primal light tracing Initialize all   = 0 for each light source with parameters p do for ray  ∈ [1,  ] do Generate exitant ray (x  ,   ) carrying flux Φ  (p) for  ∈ [1, maxBounces] do Trace ray, find intersection point (x  ,   ) → x  for  ′ local samples do   ← uniform random in H 2 for each vertex  in the triangle containing x  do for  ∈ [0, ],  ∈ [−, ] do Update coefficient   according to Eq. (

Fig. 7 .
Fig.7.Optimizing the position of a spot light such as to find a trade-off between uniformity and brightness on a Lambertian plane.The naïve gradient calculation (red dashes) fails to place the light at the correct distance from the plane.The inset illustrates how interpolation basis function gradients in the naïve approach push each ray towards the centroid of the intersected triangle, in order to increase brightness equally at all corners.Our method (blue line), in contrast, provides improved gradient information, enabling the optimizer to find the best distance.
Fig. 8. Visualizing gradients on the Stanford Dragon: the top row shows the initial (a) and intended (b) lighting, as well as their difference (c).The second row shows gradient contributions for the  coordinate of a point light using our adjoint approach (d), direct differentiation (e), and a finite difference approximation (f).Image subtitles indicate the calculation; BRDF derivatives are taken into account but not explicitly stated here for brevity.

Fig. 9 .
Fig. 9. Recovering the ground-truth position of a point light illuminating a glossy coin.initial lighting (a), the target (b), and our result (c); both ADAM and L-BFGS reliably converge to the correct result (d).The insets show differences to the target.Top row: front view, second row: side view.The top-right parts in (a, b, c) show our data structure, while the bottom-left shows a high-quality rendering of the same lighting.

Fig. 10 .
Fig. 10.Optimizing indirect illumination: a spot light placed in a simple labyrinth (a) should illuminate the target (overlaid on the far left wall), which is only reached by indirect light.The ADAM optimizer simultaneously rotates and moves the light source around the corners (b) to find the "exit" (c).

Fig. 11 .
Fig. 11.Baseline test case: moving an area light to a ground-truth position (inset images), showing the convergence of our method, PSDR and Mitsuba 3 in terms of parameter-space distance.All methods run ADAM with step size  = 0.25, 4 indirect illumination bounces and 1 million samples.On this simple scene, restricting our objective function to visible surfaces ('restricted') results in the same convergence rate as using the entire radiance data ('full').Note that Mitsuba's 'prb_reparam' method eventually converges (around 150 iterations), whereas their 'ptracer' does not.The graph on the right shows the total runtime for 100 iterations: our light tracer is ca.twice as fast as our reference path tracer, while comparing the three Mitsuba integrators shows the runtime impact of discontinuity handling.

Fig. 12 .
Fig.12.Gradient images wrt. the  coordinate of the area light for the initial state of Fig.11(primal rendering of this state and the target inset there); colour range: −0.05 (blue) to +0.05 (red).Each image uses 16 million primary samples, additional samples for discontinuity handling are stated per image as applicable.Note that Mitsuba 3's particle tracer fails to produce correct results.PSDR's path-space approach works, but light tracing causes more noise than their path tracer.Our gradient calculations ignore the moving shadow (bottom left corner), but produce comparable results to Mitsuba's standard path tracer.In particular, our adjoint light tracing produces equally clean results, while other light tracers are noticeably noisier.

Fig. 13 .
Fig. 13.Runtime (top) and convergence (middle) comparisons of our method with Mitsuba 3 on the same scene as shown in Fig. 1, modified with four cameras and four lights sources.We show results for a restricted version of our method consisting only of camera-visible data (bottom, left), as well as a full version.Four different integrators of Mitsuba 3 were used and all Mitsuba 3 tests were done with 4 million samples, while for our algorithm we chose 1, 4, and 16 million samples.The error is the Euclidean distance between current and target light positions and intensities in parameter space.Note that our full version with just 1 million samples performs similar to our restricted version using 4 times the amount of samples.Bottom row: we restrict our objective by weighting the contribution of vertices (left, white:   = 1, black:   = 0) based on their visibility to the cameras used by Mitsuba.The camera views used when optimizing with Mitsuba are shown on the right.

Fig. 17 .
Fig. 16.Lighting design study on the bust of David: we first generate a flat initial lighting of the laser-scanned model (a), then sketch a desired side lighting in 3d (b) and optimize the position and rotation of the point light source to match this target (d).We then re-create the optimized lighting setup using the real-world specimen (f).Columns (c) and (e) show the difference to the target before and after optimization respectively.

Fig. 18 .
Fig.18.Recovering light parameters for relighting an old PC game, OpenArena[2008], which originally shipped with baked lighting only: the original "look" of the game (c) is produced by combining albedo textures and lightmaps (b).From this data, we construct an optimization target (d) and use it to find a new lighting configuration (e) as close as possible to the original (c).Our optimization starts from a regular grid layout of lights and finds a suitable arrangement for them (a).Ultimately, this enables relighting old games often missing dedicated lights with more advanced rendering techniques (e.g., ray-tracing).

Fig. 19 .
Fig. 19.Lighting a theatre stage; please also refer to our accompanying video for the design interaction.The main image shows the audience view, illuminated by a spot light on the left and an area light on top.The inset on the left shows a top-down view of the stage.The inset on the right shows a part of the user-drawn lighting target.

Fig. 20 .Fig. 21 .
Fig.20.Scene from Fig.14with additional occluders: the light is placed above the ceiling (a) and must only move horizontally to best illuminate the tables (dashed lines), using the same objective as before.Gradient descent and L-BFGS fail to converge (b), while ADAM is more robust due to its momentum term.We find the true optimum by gradient-free CMA-ES optimization for comparison.
Fig.S3.Adding a box around all objects in the test scene of Fig.11, leads to different convergence behaviour.Using only camera-visible data reduces optimization performance when adding indirect illumination, whereas taking the full radiance field into account improves performance by ca.50% in terms of the number of iterations needed to reduce the parameter-space error below 0.5 (dark red bar and line).We use the same optimization and render settings as in the original test.
Fig. S2.Finite difference errors of light tracing vs. path tracing: equal time comparison, where all evaluations start with a new, arbitrary random seed.
Fig. S4.Our gradient contribution visualization under indirect illumination, showing derivatives of the objective wrt. the  coordinate (left-to-right in this view) of a spot light.Our method (a) visualizes contributions of adjoint states at the first ray-surface intersection of light paths reaching the target (b, inset) after some indirect bounces.Note that paths traversing points in the outer cone of the spot light (where the light's intensity is attenuated) would increase in brightness if the light were to move to the right, while most other surfaces prefer the light moving left.Direct (nonadjoint) differentiation (c), or finite difference approximation (d) instead visualize indirect gradient contributions at the target surface itself.Image (b) shows the global illumination solution.

Table 1 .
Overview of our results.Columns: scene reference, optimization algorithm, step size , number of primary rays (threads)  , number of mesh vertices , average time per primal and adjoint evaluation   ,  ∇ [ms], total wall clock time for the entire optimization  [s] ('*' marks average of multiple optimizations).
The flux derivative wrt. the light's position (i.e.applying a rigid translation to the light source) is thenΦ  x = Ĩ  (cos  1 / 2 ) xWhen optimizing for rotations of area lights, we now must also take into account that the ray origin x 0 on the light's surface moves when it is rotated about it's centroid, resulting in