RiTypesHelper.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 RiTypesHelper_h
#define RiTypesHelper_h

// This file is included via ri.h when using a C++ compiler.
// It represents a collection of classes that can be aliased
// atop the traditional "C" plain-ol-data representations for
// more programming expressivity without loss of performance or
// compactness.
//
// Here's an example programming idiom (for simple scalar case):
//
//  RtPoint op = {1,2,3};
//  RtPoint3 &np = reinterpret_cast<RtPoint3&>(op);
//
// Now the standard collection of operator-overriding tricks eagerly await
// your beck and call.

#include <algorithm>                    // for swap
#include <cassert>                      // for assert
#include <cfloat>                       // for FLT_MIN
#include <cmath>                        // for fabsf, sqrt, exp
#include <cstring>                      // for memcpy, memcmp
#include <functional>                   // for hash
#include <iostream>                     // for operator<<, etc
#include <cstdint>                      // int32_t, etc.

#include "RiEntrypoints.h"
#include "pxrcore/ustring/ustring.h"
#include "pxrcore/paramlist/types.h"
#include "pxrcore/paramlist/paramlist.h"
#include "pxrcore/paramlist/primvarlist.h"

typedef pxrcore::Float3 RtFloat3;
static_assert(sizeof(RtFloat3) == sizeof(float[3]), "ensure compat with legacy c-layout");
typedef RtFloat3 RtPoint3;
typedef RtFloat3 RtVector3;
typedef RtFloat3 RtNormal3;
typedef pxrcore::Matrix4x4 RtMatrix4x4;


// -------------------------------------------------------------------------
// RtFloat2 is the base class for RtPoint2, RtVector2, RtNormal2.
//  All geometrically insensitive operations are implemented here and
//  used by subclasses.  We use subclassing to preserve and convey
//  geometric-type-sensitive behavior.
class RtFloat2
{
  public:
    // allow direct member access
    float x, y;

    inline RtFloat2() = default;
    inline RtFloat2(float xx, float yy) : x(xx), y(yy) {}
    explicit inline RtFloat2(float v) : x(v), y(v) {}
    // construct from a float array
    // nb: RtFloat2(0) is ambiguous (float and NULL)
    explicit inline RtFloat2(const float *d) : x(d[0]), y(d[1]) {}

    // offer access as array (original RtPoint was float[3])
    inline float& operator[] (int i)
    {
        assert(i >= 0 && i<2);
        return (&x)[i];
    }
    inline const float& operator[] (int i) const
    {
        assert(i >= 0 && i<2);
        return (&x)[i];
    }

    // Equality comparison
    inline int operator==(const RtFloat2 &rhs) const
    {
        return x == rhs.x && y == rhs.y;
    }
    inline int operator!=(const RtFloat2 &rhs) const
    {
        return x != rhs.x || y != rhs.y;
    }

    // Lexicographical ordering
    inline bool operator<(const RtFloat2 &rhs) const
    {
        return (x < rhs.x ? true :
                x > rhs.x ? false :
                y < rhs.y);
    }

    // type cast  Too dangerous as the compiler does them automatically
    // and we can't make them explicit (not supported before C++ 11)
    // use &x[0]
    //inline operator const float *() const { return (float *) &x; }
    //inline operator float *() { return (float *) &x; }

    // serialize
    friend std::ostream& operator<<(std::ostream& o, const RtFloat2& v)
    {
        o << v.x << " " << v.y ;
        return o;
    }

    // Addition
    inline RtFloat2 operator+(const RtFloat2 &rhs) const
    {
        return RtFloat2(x + rhs.x, y + rhs.y);
    }
    inline RtFloat2 &operator+=(const RtFloat2 &rhs)
    {
        x += rhs.x;
        y += rhs.y;
        return *this;
    }
    // Subtraction
    inline RtFloat2 operator-(const RtFloat2 &rhs) const
    {
        return RtFloat2(x - rhs.x, y - rhs.y);
    }
    inline RtFloat2 &operator-=(const RtFloat2 &rhs)
    {
        x -= rhs.x;
        y -= rhs.y;
        return *this;
    }

    // Multiplication operator
    inline RtFloat2 operator*(const RtFloat2 &rhs) const
    {
        return RtFloat2(x * rhs.x, y * rhs.y);
    }
    inline RtFloat2 &operator*=(const RtFloat2 &rhs)
    {
        x *= rhs.x;
        y *= rhs.y;
        return *this;
    }

    // Division operator
    inline RtFloat2 operator/(const RtFloat2 &rhs) const
    {
        return RtFloat2(x / rhs.x, y / rhs.y);
    }
    inline RtFloat2 &operator/=(const RtFloat2 &rhs)
    {
        x /= rhs.x;
        y /= rhs.y;
        return *this;
    }

    // Unary minus
    inline RtFloat2 operator-() const { return RtFloat2(-x, -y); }

    // Scalar multiplication
    inline RtFloat2 operator*(float rhs) const
    {
        return RtFloat2(x * rhs, y * rhs);
    }
    inline friend  RtFloat2 operator*(float lhs, const RtFloat2 &rhs) {
        return rhs * lhs;
    }
    inline RtFloat2 &operator*=(float rhs)
    {
        x *= rhs;
        y *= rhs;
        return *this;
    }

    // Scalar division
    inline RtFloat2 operator/(float rhs) const
    {
        float inv = 1.0f / rhs;
        return operator*(inv);
    }
    inline RtFloat2 & operator/=(float rhs)
    {
        float inv = 1.0f / rhs;
        return operator*=(inv);
    }

    // Length
    inline float LengthSq() const
    {
        return (x*x + y*y);
    }
    inline float Length() const
    {
        return std::sqrt(LengthSq());
    }

    // Check that a vector has (approximately) unit length
    inline bool IsUnitLength(float eps=0.005f) const
    {
        float len = Length();
        return (1.0f-eps <= len && len <= 1.0f+eps);
    }

    // Normalize vector in place, return length
    inline float Normalize(float eps = FLT_MIN)
    {
        float len = LengthSq();
        if (len > eps)
        {
             len = std::sqrt(len);
             *this /= len;
        }
        else
            x = y = 0.0f;
        return len;
    }
    inline friend float Normalize(RtFloat2 &v)
    {
        return v.Normalize();
    }

    // Return normalized copy of vector
    inline RtFloat2 NormalizeCopy(const RtFloat2 &v) const
    {
        RtFloat2 copy = v;
        copy.Normalize();
        return copy;
    }
    inline friend RtFloat2 NormalizeCopy(const RtFloat2 &v)
    {
        RtFloat2 copy = v;
        copy.Normalize();
        return copy;
    }

    inline void Negate()
    {
        x = -x;
        y = -y;
    }

    // Dot product
    inline float Dot(const RtFloat2 &v2) const
    {
        return x * v2.x + y * v2.y;
    }
    inline friend float Dot(const RtFloat2 &v1, const RtFloat2 &v2)
    {
        return v1.Dot(v2);
    }

    // Absolute value of dot product
    inline float AbsDot(const RtFloat2 &v2) const
    {
        return std::abs(this->Dot(v2));
    }
    inline friend float AbsDot(const RtFloat2 &v1, const RtFloat2 &v2)
    {
        return v1.AbsDot(v2);
    }

    // Cross product
    inline float Cross(const RtFloat2 &v2) const
    {
        return x * v2.y - y * v2.x;
    }
    inline friend float Cross(const RtFloat2 &v1, const RtFloat2 &v2)
    {
        return v1.Cross(v2);
    }

    inline float ChannelAvg() const
    {
        return (x + y) * .5f;
    }

    inline float ChannelMin() const
    {
        return std::min(x, y);
    }

    inline float ChannelMax() const
    {
        return std::max(x, y);
    }

};

static_assert(sizeof(RtFloat2) == sizeof(float[2]), "ensure compat with legacy c-layout");
typedef RtFloat2 RtPoint2;
typedef RtFloat2 RtVector2;

typedef pxrcore::Float4 RtFloat4;
static_assert(sizeof(RtFloat4) == sizeof(float[4]), "ensure compat with legacy c-layout");
typedef RtFloat4 RtPoint4;

// -------------------------------------------------------------------------
// RtBBox - an axis-aligned bounding box
class RtBBox {
  public:
    // allow direct member access
    RtPoint3 min, max;

    inline RtBBox() {}
    inline RtBBox(float minx, float miny, float minz,
                  float maxx, float maxy, float maxz)
    {
        min.x = minx; min.y = miny; min.z = minz;
        max.x = maxx; max.y = maxy; max.z = maxz;
    }
    inline RtBBox(const RtPoint3 &_min, const RtPoint3 &_max)
    {
        min = _min;
        max = _max;
    }

    inline void Expand(const float expansion) {
        // Expand proportional to size near origin (i.e., interval
        // contains zero) and proportional to distance from origin
        // when farther away.  Numerically, this guarantees expansion
        // no matter where it is.
        float d;
        d = expansion * (fabsf(min.x) + fabsf(max.x));
        min.x -= d;
        max.x += d;

        d = expansion * (fabsf(min.y) + fabsf(max.y));
        min.y -= d;
        max.y += d;

        d = expansion * (fabsf(min.z) + fabsf(max.z));
        min.z -= d;
        max.z += d;
    }

    // Volume of bounding box
    inline float Volume() const
    {
        return ((max.x - min.x) *
                (max.y - min.y) *
                (max.z - min.z));
    }

    // Surface area of bounding box
    inline float SurfaceArea() const
    {
        RtVector3 diff(max - min);
        return 2.0f * (diff.x * diff.y + diff.x * diff.z + diff.y * diff.z);
    }

    // Length of the diagonal of the bounding box
    inline float Diagonal() const
    {
        return RtVector3(max - min).Length();
    }

    // Square of the length of the diagonal of the bounding box
    inline float DiagonalSq() const
    {
        return RtVector3(max - min).LengthSq();
    }

    inline RtPoint3 Center() const
    {
        return 0.5f * RtPoint3(min + max);
    }

    // Make the bounding box contain point pt
    inline void Expand(const RtPoint3 &pt)
    {
        if (pt.x < min.x) min.x = pt.x;
        if (pt.y < min.y) min.y = pt.y;
        if (pt.z < min.z) min.z = pt.z;
        if (pt.x > max.x) max.x = pt.x;
        if (pt.y > max.y) max.y = pt.y;
        if (pt.z > max.z) max.z = pt.z;
    }

    // this = this union bbox
    inline void Union(const RtBBox &bbox)
    {
        if (bbox.min.x < min.x) min.x = bbox.min.x;
        if (bbox.min.y < min.y) min.y = bbox.min.y;
        if (bbox.min.z < min.z) min.z = bbox.min.z;
        if (bbox.max.x > max.x) max.x = bbox.max.x;
        if (bbox.max.y > max.y) max.y = bbox.max.y;
        if (bbox.max.z > max.z) max.z = bbox.max.z;
    }

    // this = this intersect bbox
    inline void Intersect(const RtBBox &bbox)
    {
        if (bbox.min.x > min.x) min.x = bbox.min.x;
        if (bbox.min.y > min.y) min.y = bbox.min.y;
        if (bbox.min.z > min.z) min.z = bbox.min.z;
        if (bbox.max.x < max.x) max.x = bbox.max.x;
        if (bbox.max.y < max.y) max.y = bbox.max.y;
        if (bbox.max.z < max.z) max.z = bbox.max.z;
    }

    // Does this bounding box contain point pt?
    inline bool Contains(const RtPoint3 &pt) const
    {
        bool contains =
            (min.x < pt.x && pt.x < max.x &&
             min.y < pt.y && pt.y < max.y &&
             min.z < pt.z && pt.z < max.z);
        return contains;
    }

    // Is point pt entirely outside this bounding box?
    // (Note: a point on the surface is neither contained nor outside.)
    inline bool Outside(const RtPoint3 &pt) const
    {
        return (pt.x < min.x || max.x < pt.x ||
                pt.y < min.y || max.y < pt.y ||
                pt.z < min.z || max.z < pt.z);
    }

    // Does this bounding box entirely enclose another bounding box?
    inline bool Encloses(const RtBBox &bbox) const
    {
        return (bbox.min.x >= min.x && bbox.min.y >= min.y && bbox.min.z >= min.z &&
                bbox.max.x <= max.x && bbox.max.y <= max.y && bbox.max.z <= max.z);
    }

    // Does this bounding box overlap another bounding box?
    inline bool Overlaps(const RtBBox &bbox) const
    {
        return !(max.x <= bbox.min.x || bbox.max.x <= min.x ||
                 max.y <= bbox.min.y || bbox.max.y <= min.y ||
                 max.z <= bbox.min.z || bbox.max.z <= min.z);
    }

    // Is this bounding box intersected by the ray defined by origin
    // org and inverse direction invdir between 0 and tmax? If yes,
    // dist0 and dist1 contain the intersection points
    inline bool Intersects(const RtPoint3 &org, const RtVector3 &invdir,
        float tmax, float *dist0, float *dist1) const
    {
        float tmin = 0.0f;
        float t0, t1;

        // Compute slab intersection intervals for x component
        if (invdir.x < 0.0f) {
            t0 = (max.x - org.x) * invdir.x;
            t1 = (min.x - org.x) * invdir.x;
        } else {
            t0 = (min.x - org.x) * invdir.x;
            t1 = (max.x - org.x) * invdir.x;
        }
        // At this point, t0 and t1 is +/-inf if ray->dir.x is +/-0.
        // t0 or t1 is NaN if bbox-org is 0 and invdirx is inf (since
        // inf*0 is NaN by convention)
        if (t0 > tmin) tmin = t0;
        if (t1 < tmax) tmax = t1;
        if (tmin > tmax)
            return false; // slab interval is empty

        // Compute slab intersection intervals for y component
        if (invdir.y < 0.0f) {
            t0 = (max.y - org.y) * invdir.y;
            t1 = (min.y - org.y) * invdir.y;
        } else {
            t0 = (min.y - org.y) * invdir.y;
            t1 = (max.y - org.y) * invdir.y;
        }
        if (t0 > tmin) tmin = t0;
        if (t1 < tmax) tmax = t1;
        if (tmin > tmax)
            return false; // slab interval is empty

        // Compute slab intersection intervals for z component
        if (invdir.z < 0.0f) {
            t0 = (max.z - org.z) * invdir.z;
            t1 = (min.z - org.z) * invdir.z;
        } else {
            t0 = (min.z - org.z) * invdir.z;
            t1 = (max.z - org.z) * invdir.z;
        }
        if (t0 > tmin) tmin = t0;
        if (t1 < tmax) tmax = t1;
        if (tmin > tmax)
            return false; // slab interval is empty

        *dist0 = tmin;
        *dist1 = tmax;
        return true;
    }
};

typedef pxrcore::ColorRGB RtColorRGB;
static_assert(sizeof(RtColorRGB) == sizeof(float[3]), "ensure compat with legacy c-layout");

// -------------------------------------------------------------------------
// A simple reference counted pointer class.
//
//  To use, the templated type should be a class/struct that implements the
//  following public methods:
//
//  void IncRef()    // increment the reference count
//  void DecRef()    // decrement the reference count, deleting object when zero
//  int  GetRefCnt() // returns the current reference count
//
//  Use about the same way that you would a boost::shared_ptr<T> class, except
//  that the reference count is stored and modified within the templated type
//  (tbb::atomic or similar would be recommended for multi-threaded usage).
//
//  Portability note: When implementing DecRef() in your templated class, keep
//  in mind that it is important on Windows that the call to new/delete or
//  malloc/free of the reference-counted object happens in the same .dll / .exe.
//
//  Note: We would just use boost or tr1 reference-counted pointers instead of
//  providing this utility class, except that we don't want to introduce a
//  dependency on boost or tr1 here for a few different reasons.
//
template<typename T>
class RixRefCntPtr
{
  public:

    // Default constructor; sets the pointer value to zero.
    RixRefCntPtr() : m_ptr(0)
    {
    }

    // Construct from a direct pointer; increments the reference count.
    RixRefCntPtr(T *ptr) : m_ptr(ptr)
    {
        if (m_ptr)
            m_ptr->IncRef();
    }

    // Copy constructor; increments the reference count.
    RixRefCntPtr(RixRefCntPtr const& that)
    {
        m_ptr = that.m_ptr;
        if (m_ptr)
            m_ptr->IncRef();
    }

    // Destructor; decrements the reference count, deleting if now unused.
    ~RixRefCntPtr()
    {
        if (m_ptr)
            m_ptr->DecRef();
    }

    // Assignment operator; increment the rhs count, decrement the lhs count.
    RixRefCntPtr<T>& operator= (RixRefCntPtr<T> const &that)
    {
        if (that.m_ptr != m_ptr)
        {
            if (that.m_ptr)
                that.m_ptr->IncRef();

            if (m_ptr)
                m_ptr->DecRef();

            m_ptr = that.m_ptr;
        }

        return *this;
    }

    // Assignment operator; increment the rhs count, decrement the lhs count.
    RixRefCntPtr<T>& operator= (T *ptr)
    {
        if (m_ptr != ptr)
        {
            if (ptr)
                ptr->IncRef();

            if (m_ptr)
                m_ptr->DecRef();

            m_ptr = ptr;
        }

        return *this;
    }

    // Equality test; check if pointers are the same.
    bool operator== (RixRefCntPtr<T> const &that) const
    {
        return m_ptr == that.m_ptr;
    }

    // Equality test; check if pointers are the same.
    bool operator== (T const *ptr) const
    {
        return m_ptr == ptr;
    }

    // Inequality test; check if the pointers are different.
    bool operator!= (RixRefCntPtr<T> const &that) const
    {
        return m_ptr != that.m_ptr;
    }

    // Inequality test; check if the pointers are different.
    bool operator!= (T const *ptr) const
    {
        return m_ptr != ptr;
    }

    // Comparison operator; comparison based on memory address.
    bool operator< (RixRefCntPtr<T> const &that) const
    {
        return m_ptr < that.m_ptr;
    }

    // Comparison operator; comparison based on memory address.
    bool operator< (T const *ptr) const
    {
        return m_ptr < ptr;
    }

    // Boolean conversion operator; true when pointer is non-null.
    operator bool () const       { return m_ptr != NULL; }

    // Indirection operator; return the pointer value by reference.
    T&       operator* ()        { return *m_ptr; }
    T const& operator* () const  { return *m_ptr; }

    // Dereference operator; return the pointer value.
    T*       operator-> ()       { return m_ptr; }
    T const* operator-> () const { return m_ptr; }

    // Returns the pointer value.
    T*       GetPtr()            { return m_ptr; }
    const T* GetPtr() const      { return m_ptr; }

    // Set the pointer value without modifying the reference count.
    void     SetPtr(T *ptr)      { m_ptr = ptr; }

    // Returns the current reference count.
    int      GetRefCnt() const   { return m_ptr ? m_ptr->GetRefCnt() : 0; }

  private:

    // The pointer value.
    T *m_ptr;
};

/*
namespace RixConstants
{
    static const RtMatrix4x4 k_identityMatrix();
    static const RtMatrix4x4 k_zeroMatrix(RtVector3(0.f), 0.f);
}
*/

typedef pxrcore::UString RtUString;
#define US_NULL RtUString()

typedef pxrcore::DataType RtDataType;
typedef pxrcore::DetailType RtDetailType;
typedef pxrcore::ParamList RtParamList;
typedef pxrcore::PrimVarList RtPrimVarList;

#endif