ImplicitField.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 IMPLICITFIELD_H
#define IMPLICITFIELD_H

#include <cstddef>                      // for NULL
#include <vector>                       // for vector
#include "prmanapi.h"                   // for PRMANEXPORT
#include "ri.h"                         // for RtPoint, RtBound, etc
#include "RixInterfaces.h"

#define IMPLICIT_VER 7

class ImplicitVertexValue
{
private:
    /* inhibit copying */
    ImplicitVertexValue(const ImplicitVertexValue&);
    ImplicitVertexValue& operator=(const ImplicitVertexValue&);

public:
    ImplicitVertexValue() {}
    virtual ~ImplicitVertexValue() {}

    virtual void GetVertexValue(float* result, const RtPoint p) = 0;

    virtual void GetVertexValueFiltered(
        float* result,
        const RtPoint p,
        const RtPoint dPdu,
        const RtPoint dPdv,
        const RtPoint dPdw)
    {
        PIXAR_ARGUSED(dPdu);
        PIXAR_ARGUSED(dPdv);
        PIXAR_ARGUSED(dPdw);

        GetVertexValue(result, p);
    }

    virtual void GetVertexValueMultiple(
        int neval,
        float* result,
        int resultstride,
        const RtPoint* p)
    {
        for (int i = 0; i < neval; ++i)
        {
            GetVertexValue(result, *p++);
            result += resultstride;
        }
    }

    virtual void GetVertexValueMultipleFiltered(
        int neval,
        float* result,
        int resultstride,
        const RtPoint* p,
        const RtPoint* dPdu,
        const RtPoint* dPdv,
        const RtPoint* dPdw)
    {
        for (int i = 0; i < neval; ++i)
        {
            GetVertexValueFiltered(result, *p++, *dPdu++, *dPdv++, *dPdw++);
            result += resultstride;
        }
    }

    virtual void GetVertexValueMultipleTemporal(
        int neval,
        float* result,
        int resultstride,
        const RtPoint* p,
        const float* time)
    {
        PIXAR_ARGUSED(time);

        GetVertexValueMultiple(neval, result, resultstride, p);
    }

    virtual void GetVertexValueMultipleTemporalFiltered(
        int neval,
        float* result,
        int resultstride,
        const RtPoint* p,
        const RtPoint* dPdu,
        const RtPoint* dPdv,
        const RtPoint* dPdw,
        const float* time)
    {
        PIXAR_ARGUSED(time);

        GetVertexValueMultipleFiltered(neval, result, resultstride, p,
                                       dPdu, dPdv, dPdw);
    }

    virtual size_t MemoryUsage()
    {
        return 0;
    }
};

class ImplicitField
{
public:
    RtBound bbox;

private:
    /* inhibit copying */
    ImplicitField(const ImplicitField&);
    ImplicitField& operator=(const ImplicitField&);

public:
    ImplicitField() {}
    virtual ~ImplicitField() {}

    virtual float Eval(const RtPoint p) = 0;

    virtual float EvalFiltered(
        const RtPoint p,
        const RtPoint dPdu,
        const RtPoint dPdv,
        const RtPoint dPdw)
    {
        PIXAR_ARGUSED(dPdu);
        PIXAR_ARGUSED(dPdv);
        PIXAR_ARGUSED(dPdw);

        return Eval(p);
    }

    virtual void EvalMultiple(
        int neval,
        float* result,
        int resultstride,
        const RtPoint* p)
    {
        for (int i = 0; i < neval; ++i)
        {
            *result = Eval(*p++);
            result += resultstride;
        }
    }

    virtual void EvalMultipleFiltered(
        int neval,
        float* result,
        int resultstride,
        const RtPoint* p,
        const RtPoint* dPdu,
        const RtPoint* dPdv,
        const RtPoint* dPdw)
    {
        PIXAR_ARGUSED(dPdu);
        PIXAR_ARGUSED(dPdv);
        PIXAR_ARGUSED(dPdw);

        EvalMultiple(neval, result, resultstride, p);
    }

    virtual void GradientEval(RtPoint result, const RtPoint p) = 0;

    virtual void GradientEvalFiltered(
        RtPoint result,
        const RtPoint p,
        const RtPoint dPdu,
        const RtPoint dPdv,
        const RtPoint dPdw)
    {
        PIXAR_ARGUSED(dPdu);
        PIXAR_ARGUSED(dPdv);
        PIXAR_ARGUSED(dPdw);

        GradientEval(result, p);
    }

    virtual void GradientEvalMultiple(
        int neval,
        RtPoint* result,
        const RtPoint* p)
    {
        for (int i = 0; i < neval; ++i)
        {
            GradientEval(*result++, *p++);
        }
    }

    virtual void GradientEvalMultipleFiltered(
        int neval,
        RtPoint* result,
        const RtPoint* p,
        const RtPoint* dPdu,
        const RtPoint* dPdv,
        const RtPoint* dPdw)
    {
        PIXAR_ARGUSED(dPdu);
        PIXAR_ARGUSED(dPdv);
        PIXAR_ARGUSED(dPdw);

        GradientEvalMultiple(neval, result, p);
    }

    virtual void Range(
        RtInterval result,
        const RtPoint corners[8],
        const RtVolumeHandle h)
    {
        PIXAR_ARGUSED(corners);
        PIXAR_ARGUSED(h);

        result[0] = -1e30f;
        result[1] = 1e30f;
    }

    virtual bool ShouldSplit() { return false; }

    virtual void Split(std::vector<ImplicitField*>& children)
    {
        PIXAR_ARGUSED(children);
    }

    virtual void Motion(RtPoint result, const RtPoint p)
    {
        PIXAR_ARGUSED(p);

        result[0] = 0.0f;
        result[1] = 0.0f;
        result[2] = 0.0f;
    }

    virtual void MotionFiltered(
        RtPoint result,
        const RtPoint p,
        const RtPoint dPdu,
        const RtPoint dPdv,
        const RtPoint dPdw)
    {
        PIXAR_ARGUSED(dPdu);
        PIXAR_ARGUSED(dPdv);
        PIXAR_ARGUSED(dPdw);

        Motion(result, p);
    }

    virtual void MotionMultiple(int neval, RtPoint* result, const RtPoint* p)
    {
        for (int i = 0; i < neval; ++i)
        {
            Motion(*result++, *p++);
        }
    }

    virtual void MotionMultipleFiltered(
        int neval,
        RtPoint* result,
        const RtPoint* p,
        const RtPoint* dPdu,
        const RtPoint* dPdv,
        const RtPoint* dPdw)
    {
        PIXAR_ARGUSED(dPdu);
        PIXAR_ARGUSED(dPdv);
        PIXAR_ARGUSED(dPdw);

        MotionMultiple(neval, result, p);
    }

    virtual void BoxMotion(RtBound result, const RtBound b)
    {
        for (int i = 0; i < 6; i++)
        {
            result[i] = b[i];
        }
    }

    virtual void VolumeCompleted(const RtVolumeHandle h)
    {
        PIXAR_ARGUSED(h);
    }

    virtual ImplicitVertexValue* CreateVertexValue(
        const RtUString name,
        int nvalue)
    {
        PIXAR_ARGUSED(name);
        PIXAR_ARGUSED(nvalue);

        return 0;
    }

    virtual float MinimumVoxelSize(
        const RtPoint corners[8])
    {
        PIXAR_ARGUSED(corners);

        return 0.0f;
    }

    virtual void HullCorners(RtPoint** corners, int* ncorners)
    {
        *corners  = NULL;
        *ncorners = 0;
    }

    virtual void HullCornersMotion(
        RtPoint* corners,
        int ncorners,
        RtPoint** motioncorners,
        int* nmotioncorners)
    {
        PIXAR_ARGUSED(corners);
        PIXAR_ARGUSED(ncorners);

        *motioncorners = NULL;
        *nmotioncorners = 0;
    }

    virtual size_t MemoryUsage()
    {
        return 0;
    }
};

#define FIELDCREATE                                                       \
    extern "C" const PRMANEXPORT int ImplicitFieldVersion = IMPLICIT_VER; \
    extern "C" PRMANEXPORT ImplicitField* ImplicitFieldNew(               \
        int nfloat, const float* float0, const float* float1,             \
        int nstring, const RtString* string)

#define FIELDCREATE_ARGUSED                                               \
    PIXAR_ARGUSED(nfloat);                                                \
    PIXAR_ARGUSED(float0);                                                \
    PIXAR_ARGUSED(float1);                                                \
    PIXAR_ARGUSED(nstring);                                               \
    PIXAR_ARGUSED(string);

#endif