GU_PrimChannel.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        GU_PrimChannel.h (C++)
 *
 * COMMENTS:
 *      Utilities for Channel Primitives
 */

#ifndef __GU_PrimChannel_h__
#define __GU_PrimChannel_h__

#include "GU_API.h"
#include <GEO/GEO_PrimChannel.h>
#include "GU_Detail.h"

class UT_MemoryCounter;
class CL_SimpleChannel;

class GU_API GU_PrimChannelParms
{
public:
    GU_PrimChannelParms(GU_Detail *gdp=nullptr, GA_Offset ptoff=GA_INVALID_OFFSET);

    GU_Detail           *gdp;
    GA_Offset            ptoff;
};

class GU_PrimChannel;

class GU_API GU_PrimChannelWriteHandle
{
public:
    GU_PrimChannelWriteHandle() : myChannel(nullptr), myPrimitive(nullptr) {}
    ~GU_PrimChannelWriteHandle();

    GU_PrimChannelWriteHandle(const GU_PrimChannelWriteHandle &other) = delete;
    GU_PrimChannelWriteHandle &operator=(const GU_PrimChannelWriteHandle &other) = delete;

    GU_PrimChannelWriteHandle(GU_PrimChannelWriteHandle &&other) noexcept
    {
        myPrimitive = other.myPrimitive;
        myChannel = other.myChannel;
        other.myPrimitive = nullptr;
        other.myChannel = nullptr;
    }

    GU_PrimChannelWriteHandle &operator=(
            GU_PrimChannelWriteHandle &&other) noexcept
    {
        myPrimitive = other.myPrimitive;
        myChannel = other.myChannel;
        other.myPrimitive = nullptr;
        other.myChannel = nullptr;

        return *this;
    }

    /// Returns a pointer to a mutable CL_SimpleChannel
    inline CL_SimpleChannel *get() const { return myChannel.get(); }
    CL_SimpleChannel *operator->() const { return get(); }

protected:
    // Constructor should only be called by GU_PrimChannel
    GU_PrimChannelWriteHandle(
            GU_PrimChannel *prim,
            const UT_SharedPtr<CL_SimpleChannel> &channel);

private:
    UT_SharedPtr<CL_SimpleChannel> myChannel;

    GU_PrimChannel *myPrimitive;

    friend class GU_PrimChannel;
};

class GU_API GU_PrimChannelReadHandle
{
public:
    // Only a read handle, so no need to bump the primitive dataID
    ~GU_PrimChannelReadHandle() {}

    inline const CL_SimpleChannel *get() const { return myChannel.get(); }
    const CL_SimpleChannel *operator->() const { return get(); }

protected:
    // Constructor should only be called by GU_PrimChannel
    GU_PrimChannelReadHandle(
            const UT_SharedPtr<const CL_SimpleChannel> &channel);

private:
    UT_SharedPtr<const CL_SimpleChannel> myChannel;

    friend class GU_PrimChannel;
};

class GU_API GU_PrimChannel : public GEO_PrimChannel
{
protected:
    /// NOTE: Primitives should not be deleted directly.  They are managed
    ///       by the GA_PrimitiveList and the stash.
    ~GU_PrimChannel() override {}

public:
    /// NOTE: This constructor should only be called via GU_PrimitiveFactory.
    GU_PrimChannel(GU_Detail *gdp, GA_Offset offset=GA_INVALID_OFFSET);

    /// Report approximate memory usage.
    int64 getMemoryUsage() const override;

    /// Count memory usage using a UT_MemoryCounter in order to count
    /// shared memory correctly.
    /// NOTE: This should always include sizeof(*this).
    void countMemory(UT_MemoryCounter &counter) const override;

    const GA_PrimitiveDefinition &getTypeDef() const override
    {
        UT_ASSERT(theDefinition);
        return *theDefinition;
    }

    static GA_PrimitiveTypeId typeId()
    {
        UT_ASSERT(theDefinition);
        return theDefinition->getId();
    }

    // Conversion Methods: to polygon, nurb curve, and bezier curve
    GEO_Primitive       *convert(GEO_ConvertParms &parms,
                                 GA_PointGroup *usedpts = nullptr) override;
    GEO_Primitive       *convertNew(GEO_ConvertParms &parms) override;

    void                 normal(NormalComp &output) const override;
    void                 normal(NormalCompD &output) const override;

    int                  intersectRay(const UT_Vector3 &o, const UT_Vector3 &d,
                                float tmax = 1E17F, float tol = 1E-12F,
                                float *distance = nullptr, 
                                UT_Vector3 *pos = nullptr, 
                                UT_Vector3 *nml = nullptr, int accurate = 0,
                                float *u = nullptr, float *v = nullptr, 
                                int ignoretrim = 1) const override;

    // Returns a read-write handle to the CH_Channel
    GU_PrimChannelWriteHandle getChannelWriteHandle();
    // Returns a read-only mutable handle to the CH_Channel
    GU_PrimChannelReadHandle getChannelReadHandle() const;

    static GEO_Primitive *build(const GU_PrimChannelParms &parms, 
                                fpreal value,
                                const UT_SharedPtr<CL_SimpleChannel> &channel);

protected:
private:
    static GA_PrimitiveDefinition       *theDefinition;

    friend class                         GU_PrimitiveFactory;
SYS_DEPRECATED_PUSH_DISABLE()
};
SYS_DEPRECATED_POP_DISABLE()

#endif