RixPhotonGuiding.h

Go to the documentation of this file.

/*
# ------------------------------------------------------------------------------
#
# Copyright (c) 2020 Pixar. All rights reserved.
#
# The information in this file (the "Software") is provided for the exclusive
# use of the software licensees of Pixar ("Licensees").  Licensees have the
# right to incorporate the Software into other products for use by other
# authorized software licensees of Pixar, without fee. Except as expressly
# permitted herein, the Software may not be disclosed to third parties, copied
# or duplicated in any form, in whole or in part, without the prior written
# permission of Pixar.
#
# The copyright notices in the Software and this entire statement, including the
# above license grant, this restriction and the following disclaimer, must be
# included in all copies of the Software, in whole or in part, and all permitted
# derivative works of the Software, unless such copies or derivative works are
# solely in the form of machine-executable object code generated by a source
# language processor.
#
# PIXAR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL PIXAR BE
# LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
# OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  IN NO CASE WILL
# PIXAR'S TOTAL LIABILITY FOR ALL DAMAGES ARISING OUT OF OR IN CONNECTION WITH
# THE USE OR PERFORMANCE OF THIS SOFTWARE EXCEED $50.
#
# Pixar
# 1200 Park Ave
# Emeryville CA 94608
#
# ------------------------------------------------------------------------------
*/

#ifndef _RIX_PHOTON_GUIDING_H_
#define _RIX_PHOTON_GUIDING_H_

#include <algorithm>                    // for max, min
#include <cassert>                      // for assert
#include <cstddef>                      // for NULL
#include "prmanapi.h"                   // for PRMAN_INLINE
#include "RiTypesHelper.h"              // for RtPoint3, RtVector3, Dot, etc

// The size of one side of the projection can only be <x> smaller than distance
// from a projection plane to a projection point
#define SAMPLING_STABILITY_FACTOR 1e-4f

// Handles photon guiding
class RixPhotonGuiding
{
public:
    // The parameter probability sets with what chance will be photon guiding
    // used during photon emission.
    PRMAN_INLINE RixPhotonGuiding(float probability);

    // Sets the bounding box towards which we will guide the photons.
    // Enlarge controls whether we should enlarge the bounding box for
    // more robustness (default is 10%).
    PRMAN_INLINE void setBoundingBox(
        const RtBBox& boundingBox,
        float enlarge = 0.1f);

    PRMAN_INLINE const RtBBox& getBoundingBox() const;

    // Returns probability of choosing photon guiding
    PRMAN_INLINE float samplingPdf() const;

    // Returns true if photon guiding is enabled
    PRMAN_INLINE bool isEnabled() const;

    // Returns true if photon guiding was chosen
    // according to given random sample. Random
    // sample is also rescaled to [0,1].
    PRMAN_INLINE bool pickPhotonGuiding(float& sample) const;

    // Given a position and a normal of a light patch,
    // this methods determines whether it is possible to generate
    // photons towards bounding box.
    // onesided parameter must be set false if photons can be
    // generated from both sides of the light patch.
    PRMAN_INLINE bool canSample(
        const RtPoint3& origin,
        const RtNormal3& normal,
        bool onesided) const;

    // Tests ray origin only (no normal test) against bounding box,
    // if it is inside it returns false.
    PRMAN_INLINE bool canSample(const RtPoint3& origin) const;

    // Holds a bounding box projection on a plane
    class BoundingBoxProjection
    {
        friend class RixPhotonGuiding;

    public:
        // RixPhotonGuiding pointer may be NULL, but then we can not call
        // computeProjection methods.
        PRMAN_INLINE BoundingBoxProjection(
            const RixPhotonGuiding* photonGuiding);

        // Creates a bounding box projection on a plane
        // which lies in the middle between projectionPoint and the center
        // of the bounding box. The plane normal vector is parallel
        // to vector given by projection Point and the center of
        // the bounding box.
        // Presumes that the projectionPoint is outside the bounding box!
        // Used for direction sampling
        PRMAN_INLINE void computeProjection(const RtPoint3& projectionPoint);

        // Creates a bounding box projection on a given plane
        // Used for position sampling
        PRMAN_INLINE void computeProjection(
            const RtPoint3& projectionPoint,
            const RtPoint3& c,
            const RtNormal3& n,
            const RtVector3& s,
            const RtVector3& t);

        PRMAN_INLINE float projectionArea() const;

        // Given two random samples,
        // it generates a point on a plane within bounds
        PRMAN_INLINE RtPoint3 generatePositionOnPlane(float sx, float sy) const;

        // Given cs,ct coordinates in s,t basis,
        // it returns corresponding point in 3D
        PRMAN_INLINE RtPoint3 getPositionOnPlane(float cs, float ct) const;

        // Given cs,ct coordinates in s,t basis,
        // it returns true if they are within bounds of
        // the bounding box projection.
        PRMAN_INLINE bool isPositionOnPlane(float cs, float ct) const;
        // private:

        // Increases sampling area if projection failed due to
        // extreme size of either scene or light source
        PRMAN_INLINE void stabilizeSampling(float min);

        // RixPhotonGuiding reference
        const RixPhotonGuiding* m_photonGuiding;
        // Projection point
        RtPoint3 m_projectionPoint;
        // Orthonormal basis of the projection plane
        RtVector3 m_n;
        RtVector3 m_s;
        RtVector3 m_t;
        // Center of the projection plane
        RtPoint3 m_c;
        // Precomputed factor needed for plane intersection tests
        // (also used by other function (e.g. directionPdf)
        float m_d;
        // Projection min & max coordinates in s,t basis
        // [minS, minT, maxS, maxT]
        float m_stCoords[4];
        // Projection size in s,t basis
        float m_sizeS;
        float m_sizeT;
    };

    // Given ray origin (+normal) and a bounding box projection it can
    // generate random direction towards the bounding box (using two random
    // samples provided by caller). Returns generated direction, cosTheta, pdf.
    // The returned pdf is wrt to solid angle measure.
    // Will return correct results only if canSampleTowardsBBox is true.
    PRMAN_INLINE void sampleDirection(
        const RtPoint3& origin,
        const RtNormal3& normal,
        const BoundingBoxProjection& bbp,
        float samplex,
        float sampley,
        // output
        RtVector3& direction,
        float& cosTheta,
        float& pdf) const;

    // Returns pdf of direction towards the bounding box given ray origin
    // and a bounding box projection.
    // The returned pdf is wrt to solid angle measure.
    PRMAN_INLINE float directionPdf(
        const RtPoint3& origin,
        const BoundingBoxProjection& bbp,
        const RtVector3& direction) const;

    // Given a bounding box projection it can
    // generate a random position on a plane facing the bounding box
    // (using two random samples provided by caller).
    // Returns generated position and pdf. The returned pdf is wrt to
    // area measure.
    PRMAN_INLINE void samplePosition(
        const BoundingBoxProjection& bbp,
        float samplex,
        float sampley,
        // output
        RtPoint3& position,
        float& pdf) const;

    // Returns pdf of position on the projected bounding box
    // given a position and bounding box projection.
    // The returned pdf is wrt to area measure.
    // Assumes that the position is on the projection plane.
    PRMAN_INLINE float positionPdf(
        const RtPoint3& position,
        const BoundingBoxProjection& bbp) const;

    // Uses MIS to combine supplied direction pdf with photon guiding
    // pdf. It also requires position on a light source, corresponding
    // normal and direction. Paramater onesided indicates whether
    // light emits photons from only one side.
    PRMAN_INLINE float MISAreaLightPdf(
        const RtPoint3& position,
        const RtNormal3& normal,
        const RtVector3& direction,
        bool onesided,
        float dirPdf) const;

    // Uses MIS to combine supplied position pdf with photon guiding
    // pdf. It also requires direction to env. map, position in scene
    // (path vertex prior to env.map), world/env map center and world/
    // env map radius.
    PRMAN_INLINE float MISEnvLightPdf(
        const RtVector3& dirToEnv,
        const RtPoint3& posInScene,
        const RtPoint3& center,
        float radius,
        float posPdf) const;

    // Normalizes n and then computes rest of the orthonormal basis
    PRMAN_INLINE static void computeOrthonormalBasis(
        RtVector3& n,
        // output
        RtVector3& s,
        RtVector3& t);

private:
    // Inits internal variables (should be called after each bbox change)
    PRMAN_INLINE void init(float enlarge);

    // Photons preferred area bbox
    RtBBox m_boundingBox;
    // Probability of sampling according to the bbox
    float m_probability;
    // True if bounding box has volume
    bool m_hasVolume;
    // Stores corners of bounding box
    RtPoint3 m_corners[8];
    // Center of bounding box
    RtPoint3 m_center;
};

// The probability parameter sets with what chance photon guiding will be
// used during photon emission.
PRMAN_INLINE
RixPhotonGuiding::RixPhotonGuiding(float probability)
    : m_probability(probability)
{
    assert(m_probability >= 0.0f && m_probability <= 1.0f);
    m_boundingBox.min = RtPoint3(0.0f);
    m_boundingBox.max = RtPoint3(0.0f);
    init(false);
}

// Sets the bounding box towards which we will guide the photons.
// Enlarge controls whether we should enlarge the bounding box for
// more robustness (default is 10%).
PRMAN_INLINE void
RixPhotonGuiding::setBoundingBox(const RtBBox& boundingBox, float enlarge)
{
    m_boundingBox = boundingBox;
    init(enlarge);
}

PRMAN_INLINE const RtBBox&
RixPhotonGuiding::getBoundingBox() const
{
    return m_boundingBox;
}

// Returns probability of choosing photon guiding
PRMAN_INLINE float
RixPhotonGuiding::samplingPdf() const
{
    return m_probability;
}

// Returns true if photon guiding is enabled
PRMAN_INLINE bool
RixPhotonGuiding::isEnabled() const
{
    return m_hasVolume && m_probability > 0.0f;
}

// Returns true if photon guiding was chosen
// according to given random sample. Random
// sample is also rescaled to [0,1].
PRMAN_INLINE bool
RixPhotonGuiding::pickPhotonGuiding(float& sample) const
{
    if (sample < m_probability)
    {
        sample = sample / m_probability;
        return true;
    }
    else
    {
        sample = (sample - m_probability) / (1.0f - m_probability);
        return false;
    }
}

// Given a position and a normal of a light patch,
// this methods determines whether it is possible to generate
// photons towards bounding box.
// onesided parameter must be set false if photons can be
// generated from both sides of the light patch.
PRMAN_INLINE bool
RixPhotonGuiding::canSample(
    const RtPoint3& origin,
    const RtNormal3& normal,
    bool onesided) const
{
    return !(m_boundingBox.Contains(origin)) &&
           (!onesided ||
               !(Dot(normal, m_boundingBox.min - origin) < 0.0f &&
                 Dot(normal, m_boundingBox.max - origin) < 0.0f));
}

// Tests ray origin only (no normal test) against bounding box,
// if it is inside it returns false.
PRMAN_INLINE bool
RixPhotonGuiding::canSample(const RtPoint3& origin) const
{
    return !m_boundingBox.Contains(origin);
}

// Given ray origin (+normal) and a bounding box projection it can
// generate random direction towards the bounding box (using two random
// samples provided by caller). Returns generated direction, cosTheta, pdf.
// The returned pdf is wrt to solid angle measure.
// Will return correct results only if canSampleTowardsBBox is true.
PRMAN_INLINE void
RixPhotonGuiding::sampleDirection(
    const RtPoint3& origin,
    const RtNormal3& normal,
    const BoundingBoxProjection& bbp,
    float samplex,
    float sampley,
    // output
    RtVector3& direction,
    float& cosTheta,
    float& pdf) const
{
    // finally sample inside projection
    RtPoint3 posOnPlane = bbp.generatePositionOnPlane(samplex, sampley);
    // compute direction from origin towards the sample
    direction = posOnPlane - origin;
    // compute distance^2
    float dist2 = Dot(direction, direction);
    direction.Normalize();
    cosTheta = AbsDot(direction, normal);
    // as a last step we need to compute pdf and convert it
    // to solid angle measure
    // pdf = dist2 / ( bbp.projectionArea() * Dot(direction, bbp.m_n) );
    pdf = dist2 / (bbp.projectionArea() * Dot(direction, bbp.m_n));
}

// Returns pdf of direction towards the bounding box given ray origin
// and a bounding box projection.
// The returned pdf is wrt to solid angle measure.
PRMAN_INLINE float
RixPhotonGuiding::directionPdf(
    const RtPoint3& origin,
    const BoundingBoxProjection& bbp,
    const RtVector3& direction) const
{
    // compute ray intersection with plane
    float nvInv = 1.0f / Dot(bbp.m_n, direction);
    // to compute intersection of ray and plane we need this precomputation
    float dno = bbp.m_d - Dot(bbp.m_n, origin);
    // ray from c to projection on plane
    RtVector3 hitRay = dno * nvInv * direction + origin - bbp.m_c;
    float hitS = Dot(hitRay, bbp.m_s);
    float hitT = Dot(hitRay, bbp.m_t);
    // is hit in 2d bbox
    if (bbp.isPositionOnPlane(hitS, hitT))
    {
        RtPoint3 posOnPlane = bbp.getPositionOnPlane(hitS, hitT);
        RtVector3 d = posOnPlane - origin;
        return Dot(d, d) / (bbp.projectionArea() * Dot(direction, bbp.m_n));
    }
    else
        return 0.0f;
}

// Given a bounding box projection it can
// generate a random position on a plane facing the bounding box
// (using two random samples provided by caller).
// Returns generated position and pdf. The returned pdf is wrt to
// area measure.
PRMAN_INLINE void
RixPhotonGuiding::samplePosition(
    const BoundingBoxProjection& bbp,
    float samplex,
    float sampley,
    // output
    RtPoint3& position,
    float& pdf) const
{
    // sample inside projection
    position = bbp.generatePositionOnPlane(samplex, sampley);
    pdf      = 1.0f / bbp.projectionArea();
}

// Returns pdf of position on the projected bounding box
// given a position and bounding box projection.
// The returned pdf is wrt to area measure.
// Assumes that the position is on the projection plane.
PRMAN_INLINE float
RixPhotonGuiding::positionPdf(
    const RtPoint3& position,
    const BoundingBoxProjection& bbp) const
{
    RtVector3 hitRay = position - bbp.m_c;
    hitRay -= bbp.m_n * bbp.m_n.Dot(hitRay);
#ifndef NDEBUG
    RtVector3 hrn = hitRay;
    hrn.Normalize();
    assert(AbsDot(hrn, bbp.m_n) < 0.001f);
#endif
    float hitS = Dot(hitRay, bbp.m_s);
    float hitT = Dot(hitRay, bbp.m_t);
    // is hit in 2d bbox
    if (bbp.isPositionOnPlane(hitS, hitT))
        return 1.0f / bbp.projectionArea();
    else
        return 0.0f;
}

// Uses MIS to combine supplied direction pdf with photon guiding
// pdf. It also requires position on a light source, corresponding
// normal and direction. Paramater onesided indicates whether
// light emits photons from only one side.
PRMAN_INLINE float
RixPhotonGuiding::MISAreaLightPdf(
    const RtPoint3& position,
    const RtNormal3& normal,
    const RtVector3& direction,
    bool onesided,
    float dirPdf) const
{
    if (isEnabled() && canSample(position, normal, onesided))
    {
        BoundingBoxProjection bboxProjection(this);
        bboxProjection.computeProjection(position);
        float otherPdf = directionPdf(position, bboxProjection, direction);
        // Use multiple importance sampling
        return otherPdf * samplingPdf() + dirPdf * (1.0f - samplingPdf());
    }
    return dirPdf;
}

// Uses MIS to combine supplied position pdf with photon guiding
// pdf. It also requires direction to env. map, position in scene
// (path vertex prior to env.map), world/env map center and world/
// env map radius.
PRMAN_INLINE float
RixPhotonGuiding::MISEnvLightPdf(
    const RtVector3& dirToEnv,
    const RtPoint3& posInScene,
    const RtPoint3& center,
    float radius,
    float posPdf) const
{
    RtVector3 v = dirToEnv * radius;
    RtPoint3 centerPoint = v + center;
    if (isEnabled() && canSample(centerPoint))
    {
        RtVector3 projectionPoint = v * 2.0f + center; // (actually a point)
        RtVector3 t, s;
        computeOrthonormalBasis(v, s, t);
        BoundingBoxProjection bbp(this);
        bbp.computeProjection(projectionPoint, centerPoint, -v, s, t);
        // Now we have to compute position on the projection plane
        float dno = bbp.m_d - Dot(bbp.m_n, posInScene);
        RtVector3 hit = -dno * v + posInScene;
        float otherPdf = positionPdf(hit, bbp);
        // Use multiple importance sampling
        return otherPdf * samplingPdf() + posPdf * (1.0f - samplingPdf());
    }
    return posPdf;
}

// Normalizes n and then computes rest of the orthonormal basis
PRMAN_INLINE void
RixPhotonGuiding::computeOrthonormalBasis(
    RtVector3& n,
    // output
    RtVector3& s,
    RtVector3& t)
{
    Normalize(n);
    const RtVector3 t1 = (n.x * n.x > n.y * n.y) ? RtVector3(0.0f, 1.0f, 0.0f)
                                                 : RtVector3(1.0f, 0.0f, 0.0f);
    s = Cross(t1, n);
    Normalize(s);
    t = Cross(n, s);
    Normalize(t);
}

// Inits internal variables (should be called after each bbox change)
PRMAN_INLINE void
RixPhotonGuiding::init(float enlarge)
{
    // Enlarge bounding box for more robust guiding (only for auto mode)
    if (enlarge > 0.0f)
    {
        // Expands the bounding by 10% on both sides
        RtVector3 expand = (m_boundingBox.max - m_boundingBox.min) * enlarge;
        m_boundingBox.min -= expand;
        m_boundingBox.min += expand;
    }
    // Precompute important bbox properties
    // clang-format off
    m_corners[0] = m_boundingBox.min;
    m_corners[1] = m_boundingBox.max,
    m_corners[2] = RtPoint3(m_boundingBox.min.x, m_boundingBox.min.y, m_boundingBox.max.z);
    m_corners[3] = RtPoint3(m_boundingBox.min.x, m_boundingBox.max.y, m_boundingBox.min.z);
    m_corners[4] = RtPoint3(m_boundingBox.max.x, m_boundingBox.min.y, m_boundingBox.min.z);
    m_corners[5] = RtPoint3(m_boundingBox.min.x, m_boundingBox.max.y, m_boundingBox.max.z);
    m_corners[6] = RtPoint3(m_boundingBox.max.x, m_boundingBox.min.y, m_boundingBox.max.z);
    m_corners[7] = RtPoint3(m_boundingBox.max.x, m_boundingBox.max.y, m_boundingBox.min.z);
    m_center     = (m_boundingBox.max + m_boundingBox.min) * 0.5f;
    m_hasVolume  = m_boundingBox.Volume() > 0.0f;
    // clang-format on
}

// RixPhotonGuiding pointer may be NULL, but then we can not call
// computeProjection methods.
PRMAN_INLINE
RixPhotonGuiding::BoundingBoxProjection::BoundingBoxProjection(
    const RixPhotonGuiding* photonGuiding)
    : m_photonGuiding(photonGuiding) // Maybe NULL
{
}

// Creates a bounding box projection on a plane
// which lies in the middle between projectionPoint and the center
// of the bounding box. The plane normal vector is parallel
// to vector given by projection Point and the center of
// the bounding box.
// Presumes that the projectionPoint is outside the bounding box!
// Used for direction sampling from area light
PRMAN_INLINE void
RixPhotonGuiding::BoundingBoxProjection::computeProjection(
    const RtPoint3& projectionPoint)
{
    assert(!m_photonGuiding->m_boundingBox.Contains(projectionPoint));
    assert(m_photonGuiding != NULL);

    m_projectionPoint = projectionPoint;
    // compute plane normal
    m_n = m_photonGuiding->m_center - projectionPoint;
    // center of the plane facing bbox
    RtPoint3 cpp = m_n * 0.5f; // c - projectionPoint
    m_c = cpp + projectionPoint;
    // compute two vectors perpendicular to n (and normalize n)
    computeOrthonormalBasis(m_n, m_s, m_t);

    // d from plane equation n . p = d
    m_d = Dot(m_n, m_c);
    // to compute intersection of corners and plane we need this
    // precomputation
    float dno = m_d - Dot(m_n, projectionPoint);
    // 2d bbox init
    m_stCoords[0] = m_stCoords[1] = FLT_MAX;  // min
    m_stCoords[2] = m_stCoords[3] = -FLT_MAX; // max
    // project each corner of the bbox and update stCoords
    for (int i = 0; i < 8; ++i)
    {
        RtVector3 v = m_photonGuiding->m_corners[i] - projectionPoint;
        // can't be inf (projectionPoint is outside bbox)
        float nvInv = 1.0f / Dot(m_n, v);
        // ray from c to projection on plane
        RtVector3 hitRay = dno * nvInv * v - cpp;
        float hitS       = Dot(hitRay, m_s);
        float hitT       = Dot(hitRay, m_t);
        m_stCoords[0]    = std::min(m_stCoords[0], hitS);
        m_stCoords[1]    = std::min(m_stCoords[1], hitT);
        m_stCoords[2]    = std::max(m_stCoords[2], hitS);
        m_stCoords[3]    = std::max(m_stCoords[3], hitT);
    }
    // Compute projection size
    m_sizeS = m_stCoords[2] - m_stCoords[0];
    m_sizeT = m_stCoords[3] - m_stCoords[1];
    stabilizeSampling(
        (m_c - projectionPoint).Length() * SAMPLING_STABILITY_FACTOR);
}

// Creates a bounding box projection on a given plane.
// Used for position sampling for environment light
PRMAN_INLINE void
RixPhotonGuiding::BoundingBoxProjection::computeProjection(
    const RtPoint3& projectionPoint, // only used to stabilize
    const RtPoint3& c,
    const RtNormal3& n,
    const RtVector3& s,
    const RtVector3& t)
{
    assert(m_photonGuiding != NULL);
    assert(!m_photonGuiding->m_boundingBox.Contains(projectionPoint));

    m_projectionPoint = projectionPoint;
    m_c               = c;
    m_n               = n;
    m_s               = s;
    m_t               = t;
    // d from plane equation n . p = d
    m_d = Dot(m_n, m_c);
    // to compute intersection of corners and plane we need this
    // precomputation

    // 2d bbox init
    m_stCoords[0] = m_stCoords[1] = FLT_MAX;  // min
    m_stCoords[2] = m_stCoords[3] = -FLT_MAX; // max
    // project each corner of the bbox and update stCoords
    for (int i = 0; i < 8; ++i)
    {
        RtPoint3 cornerpt = m_photonGuiding->m_corners[i];
        float dist        = Dot(m_n, (cornerpt - c));
        RtVector3 hitRay  = cornerpt - dist * m_n - c;
        float hitS        = Dot(hitRay, m_s);
        float hitT        = Dot(hitRay, m_t);
        m_stCoords[0]     = std::min(m_stCoords[0], hitS);
        m_stCoords[1]     = std::min(m_stCoords[1], hitT);
        m_stCoords[2]     = std::max(m_stCoords[2], hitS);
        m_stCoords[3]     = std::max(m_stCoords[3], hitT);
    }
    // Compute projection size
    m_sizeS = m_stCoords[2] - m_stCoords[0];
    m_sizeT = m_stCoords[3] - m_stCoords[1];
    stabilizeSampling(
        (m_c - projectionPoint).Length() * SAMPLING_STABILITY_FACTOR);
}

PRMAN_INLINE float
RixPhotonGuiding::BoundingBoxProjection::projectionArea() const
{
    return m_sizeS * m_sizeT;
}

// Given two random samples,
// generate a point on a plane within bounds
PRMAN_INLINE RtPoint3
RixPhotonGuiding::BoundingBoxProjection::generatePositionOnPlane(
    float sx,
    float sy) const
{
    return m_c + (m_sizeS * sx + m_stCoords[0]) * m_s +
                 (m_sizeT * sy + m_stCoords[1]) * m_t;
}

// Given cs,ct coordinates in s,t basis,
// return corresponding point in 3D
PRMAN_INLINE RtPoint3
RixPhotonGuiding::BoundingBoxProjection::getPositionOnPlane(
    float cs,
    float ct) const
{
    return m_c + cs * m_s + ct * m_t;
}

// Given cs,ct coordinates in s,t basis,
// return true if they are within bounds of
// the bounding box projection.
PRMAN_INLINE bool
RixPhotonGuiding::BoundingBoxProjection::isPositionOnPlane(
    float cs,
    float ct) const
{
    return (cs >= m_stCoords[0] && cs <= m_stCoords[2] && 
            ct >= m_stCoords[1] && ct <= m_stCoords[3]);
}

// Increases sampling area if projection failed due to
// extreme size of either scene or light source
PRMAN_INLINE void
RixPhotonGuiding::BoundingBoxProjection::stabilizeSampling(float min)
{
    if (m_sizeS < min)
    {
        float mid     = 0.5f * (m_stCoords[2] + m_stCoords[0]);
        m_sizeS       = min;
        m_stCoords[2] = mid + min * 0.5f;
        m_stCoords[0] = mid - min * 0.5f;
    }
    if (m_sizeT < min)
    {
        float mid     = 0.5f * (m_stCoords[3] + m_stCoords[1]);
        m_sizeT       = min;
        m_stCoords[3] = mid + min * 0.5f;
        m_stCoords[1] = mid - min * 0.5f;
    }
}

#endif // _RIX_PHOTON_GUIDING_H_