Initial commit.

Framework/lights/spot_light.cpp

@@ -0,0 +1,136 @@
+// Copyright 2009-2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+
+#include "light.h"
+#include <sampling.hpp>
+#include <math/linearspace3.h>
+#include "helper.hpp"
+
+namespace embree {
+    struct SpotLight {
+        Light super; //!< inherited light fields
+
+        Vec3fa position; //!< Position of the SpotLight
+        LinearSpace3fa frame; //!< coordinate frame, with vz == direction that the SpotLight is emitting
+        Vec3fa power; //!< RGB color and intensity of the SpotLight
+        float cosAngleMax; //!< Angular limit of the spot in an easier to use form: cosine of the half angle in radians
+        float cosAngleScale; //!< 1/(cos(border of the penumbra area) - cosAngleMax); positive
+        float radius; //!< defines the size of the (extended) SpotLight
+        float diskPdf; //!< pdf of disk with radius
+    };
+
+
+    // Implementation
+    //////////////////////////////////////////////////////////////////////////////
+
+    Light_SampleRes SpotLight_sample(const Light* super,
+                                     const Sample& dg,
+                                     const Vec2f& s) {
+        const SpotLight* self = (SpotLight *) super;
+        Light_SampleRes res;
+
+        // extant light vector from the hit point
+        res.dir = self->position - dg.P;
+
+        if (self->radius > 0.0f)
+            res.dir = self->frame * uniformSampleDisk(self->radius, s) + res.dir;
+
+        const float dist2 = dot(res.dir, res.dir);
+        const float invdist = rsqrt(dist2);
+
+        // normalized light vector
+        res.dir = res.dir * invdist;
+        res.dist = dist2 * invdist;
+
+        // cosine of the negated light direction and light vector.
+        const float cosAngle = -dot(self->frame.vz, res.dir);
+        const float angularAttenuation = clamp((cosAngle - self->cosAngleMax) * self->cosAngleScale);
+
+        if (self->radius > 0.0f)
+            res.pdf = self->diskPdf * dist2 * abs(cosAngle);
+        else
+            res.pdf = inf; // we always take this res
+
+        // convert from power to radiance by attenuating by distance^2; attenuate by angle
+        res.weight = self->power * (sqr(invdist) * angularAttenuation);
+
+        return res;
+    }
+
+    Light_EvalRes SpotLight_eval(const Light* super,
+                                 const Sample& dg,
+                                 const Vec3fa& dir) {
+        const SpotLight* self = (SpotLight *) super;
+        Light_EvalRes res;
+        res.value = Vec3fa(0.0f);
+        res.dist = inf;
+        res.pdf = 0.0f;
+
+        if (self->radius > 0.0f) {
+            // intersect disk
+            const float cosAngle = -dot(dir, self->frame.vz);
+            if (cosAngle > self->cosAngleMax) {
+                // inside illuminated cone?
+                const Vec3fa vp = dg.P - self->position;
+                const float dp = dot(vp, self->frame.vz);
+                if (dp > 0.0f) {
+                    // in front of light?
+                    const float t = dp * rcp(cosAngle);
+                    const Vec3fa vd = vp + t * dir;
+                    if (dot(vd, vd) < sqr(self->radius)) {
+                        // inside disk?
+                        const float angularAttenuation = min((cosAngle - self->cosAngleMax) * self->cosAngleScale, 1.f);
+                        const float pdf = self->diskPdf * cosAngle;
+                        res.value = self->power * (angularAttenuation * pdf); // *sqr(t)/sqr(t) cancels
+                        res.dist = t;
+                        res.pdf = pdf * sqr(t);
+                    }
+                }
+            }
+        }
+
+        return res;
+    }
+
+
+    // Exports (called from C++)
+    //////////////////////////////////////////////////////////////////////////////
+
+    //! Set the parameters of an ispc-side SpotLight object
+    extern "C" void SpotLight_set(void* super,
+                                  const Vec3fa& position,
+                                  const Vec3fa& direction,
+                                  const Vec3fa& power,
+                                  float cosAngleMax,
+                                  float cosAngleScale,
+                                  float radius) {
+        SpotLight* self = (SpotLight *) super;
+        self->position = position;
+        self->frame = frame(direction);
+        self->power = power;
+        self->cosAngleMax = cosAngleMax;
+        self->cosAngleScale = cosAngleScale;
+        self->radius = radius;
+        self->diskPdf = uniformSampleDiskPDF(radius);
+    }
+
+    //! Create an ispc-side SpotLight object
+    extern "C" void* SpotLight_create() {
+        SpotLight* self = (SpotLight *) alignedUSMMalloc(sizeof(SpotLight), 16);
+
+        Light_Constructor(&self->super);
+        //self->super.sample = GET_FUNCTION_POINTER(SpotLight_sample);
+        //self->super.eval = GET_FUNCTION_POINTER(SpotLight_eval);
+        self->super.type = LIGHT_SPOT;
+
+        SpotLight_set(self,
+                      Vec3fa(0.f),
+                      Vec3fa(0.f, 0.f, 1.f),
+                      Vec3fa(1.f),
+                      0.f,
+                      100.f,
+                      0.f);
+
+        return self;
+    }
+} // namespace embree