RixManifoldWalkConnection.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 RixManifoldWalkConnection_h
#define RixManifoldWalkConnection_h


// Stucture used to recover results of the manifold walk
struct RixMWConnectionResult
{
    // throughput along the caustic path found
    RtColorRGB *throughput;
    // Direction of the new connection (bxdf side)
    RtVector3 *dir;
    // Direction of the new connection (light side)
    RtVector3 *toLight;
    // Position of the last vertex on the caustic path
    RtPoint3 *lastPoint;
    // Distance between the last vertex and the point on the light source
    float *dist;
    // Distance between two starting vertices
    float *distDirect;

    RtColorRGB *transmission;

    float *pdf;

    float *geoTerm;

    bool *hasConverged;

    int _maxSize;

    // when !_isDirty, Clear() is very cheap. 
    bool _isDirty; 

    RixMWConnectionResult() :
        throughput(0x0),
        dir(0x0),
        toLight(0x0),
        lastPoint(0x0),
        dist(0x0),
        distDirect(0x0),
        transmission(0x0),
        pdf(0x0),
        geoTerm(0x0),
        hasConverged(0x0),
        _maxSize(0),
        _isDirty(true)
    {
    }

    ~RixMWConnectionResult()
    {
        delete[] throughput; throughput = 0x0;
        delete[] dir; dir = 0x0;
        delete[] toLight; toLight= 0x0;
        delete[] lastPoint; lastPoint = 0x0;
        delete[] pdf; pdf = 0x0;
        delete[] dist; dist = 0x0;
        delete[] distDirect; distDirect = 0x0;
        delete[] hasConverged; hasConverged = 0x0;
        delete[] transmission; transmission = 0x0;
    }

    void Clear()
    {
        //std::fill_n(pdf, _maxSize, 0.f); // not needed since Init() overwrites this anyway
        if (_isDirty) 
        {
            std::fill_n(hasConverged, _maxSize, false);
            std::fill_n(throughput, _maxSize, RtColorRGB(0.f));
            std::fill_n(transmission, _maxSize, RtColorRGB(0.f));
            std::fill_n(dist, _maxSize, 0.f);
            std::fill_n(distDirect, _maxSize, 0.f);
            _isDirty = false;
        }
    }

    void Init(float* initPDF)
    {
        _isDirty = true; // we are about to start modifying this struct

        if (initPDF)
        {
            memcpy(pdf, initPDF, _maxSize*sizeof(float)); 
        } 
        else
        {
            std::fill_n(pdf, _maxSize, 1.0f);
        }

        std::fill_n(hasConverged, _maxSize, false);
    }

    void Allocate(int maxSize)
    {
        throughput  = new RtColorRGB[maxSize];
        dir         = new RtVector3[maxSize];
        toLight     = new RtVector3[maxSize];
        lastPoint   = new RtPoint3[maxSize];
        dist        = new float[maxSize];
        distDirect  = new float[maxSize];
        pdf         = new float[maxSize];
        hasConverged = new bool[maxSize];
        transmission = new RtColorRGB[maxSize];
        _maxSize = maxSize;
    }
};

#endif