GEO_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:        Geometry Library (C++)
 *
 * COMMENTS:    Channel primitive.
 */

#ifndef __GEO_PrimChannel_H__
#define __GEO_PrimChannel_H__

#include "GEO_API.h"
#include "GEO_Detail.h"
#include "GEO_Primitive.h"
#include "GEO_PrimType.h"
#include "GEO_Vertex.h"

#include <GA/GA_Detail.h>
#include <UT/UT_StringHolder.h>

class CL_SimpleChannel;

class GEO_API GEO_PrimChannel : public GEO_Primitive
{
protected:
    /// NOTE: The constructor should only be called from subclass
    ///       constructors.
    GEO_PrimChannel(GEO_Detail *d, GA_Offset offset=GA_INVALID_OFFSET);

    /// NOTE: The destructor should only be called from subclass
    ///       destructors.
    ~GEO_PrimChannel() override {}

public:
    bool                getBBox(UT_BoundingBox *bbox) const override;
    UT_Vector3          baryCenter() const override;
    UT_Vector3D         computeNormalD() const override;
    UT_Vector3          computeNormal() const override;

    /// Before a point is deleted, all primitives using the point will be
    /// notified.  The method should return "false" if it's impossible to
    /// delete the point.  Otherwise, the vertices should be removed.
    GA_DereferenceStatus        dereferencePoint(
                                        GA_Offset point,
                                        bool dry_run=false) override;
    GA_DereferenceStatus        dereferencePoints(
                                        const GA_RangeMemberQuery &pt_q,
                                        bool dry_run=false) override;


    bool                        isDegenerate() const override;
    void                        reverse() override;
    // Take the whole set of points into consideration when applying the
    // point removal operation to this primitive. The method returns 0 if
    // successful, -1 if it failed because it would have become degenerate,
    // and -2 if it failed because it would have had to remove the primitive
    // altogether.
    int                         detachPoints(GA_PointGroup &grp) override;

    /// Though not strictly required (i.e. not pure virtual), these methods
    /// should be implemented for proper behaviour.
    GEO_Primitive      *copy(int preserve_shared_pts = 0) const override;
    void                copyPrimitive(const GEO_Primitive *src) override;
    void                copySubclassData(const GA_Primitive *source) override;

    // Have we been deactivated and stashed?
    void                stashed(bool beingstashed,
                                GA_Offset offset=GA_INVALID_OFFSET) override;

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

    SYS_FORCE_INLINE
    int64 getDataId() const { return myDataId; }

    SYS_FORCE_INLINE
    void assignNewDataId() { myDataId = nextDataId(); }

    SYS_FORCE_INLINE
    void bumpDataId()
    {
        if (myDataId != INVALID_DATA_ID)
            assignNewDataId();
    }

    /// Append a vertex. For the channel primitive, Vertices are used to refer
    /// to a point which uses the underlying channel.
    GA_Size             appendVertex(GA_Offset ptoff);

    /// @{
    /// Save/Load properties to a JSON stream
    bool saveVertexArray(UT_JSONWriter &w, const GA_SaveMap &map) const;
    bool loadVertexArray(UT_JSONParser &p, const GA_LoadMap &map);
    bool saveChannel(UT_JSONWriter &w, const GA_SaveMap &map) const;
    bool loadChannel(UT_JSONParser &p, const GA_LoadMap &map);
    /// @}

    bool saveChannelProperties(UT_JSONWriter &w) const;

    const GA_PrimitiveJSON *getJSON() const override;

    static GEO_PrimChannel *build(GA_Detail *gdp,
                                fpreal value,
                                const UT_SharedPtr<CL_SimpleChannel> &channel);

protected:
    /// Register intrinsic attributes
    GA_DECLARE_INTRINSICS(override)

    static GA_PrimitiveFamilyMask       buildFamilyMask()
                            { return GA_FAMILY_NONE; }

    // Evaluate the position or the derivative at domain point (u,v), where
    // u and v MUST be in [0,1]. "v" and "dv" will be ignored here. Return 0 if
    // OK and -1 otherwise.
    bool                evaluatePointRefMap(
                                GA_Offset result_vtx,
                                GA_AttributeRefMap &hlist,
                                fpreal u_unit, fpreal,
                                uint du, uint) const override;
    int                 evaluatePointV4(
                                UT_Vector4 &pos,
                                float u_unit, float=0,
                                unsigned du=0, unsigned = 0) const override;

    // This should only be called from GU_Primitive
    // External access to the channel should be done through the GU layer's
    // getChannel{Read,Write}Handle
    UT_SharedPtr<CL_SimpleChannel> getChannel();

    UT_SharedPtr<const CL_SimpleChannel> getConstChannel() const;

private:
    static int64                         INVALID_DATA_ID;

    UT_SharedPtr<CL_SimpleChannel>       myChannel;

    int64                                myDataId;

    static int64                         nextDataId();

    friend std::ostream &operator<<(std::ostream &os, const GEO_PrimChannel &d)
                        {
                            d.saveH9(os, 0,
                                     GEO_Primitive::theEmptySaveAttribs,
                                     GEO_Primitive::theEmptySaveAttribs);
                            return os;
                        }
};
#endif