POP/POP_GenVar.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.
 *
 * Produced by:
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 */

#ifndef __POP_GenVar_h__
#define __POP_GenVar_h__

#include "POP_API.h"
#include "POP_Node.h"

// This subclass exists to handle functions common to generators including
// generator variables.

class POP_API POP_GenVar : public POP_Node
{
public:

    static CH_LocalVariable     myVariables[];
    static OP_VariablePair      myVariablePair;

    static OP_TemplatePair      myTemplatePair;

protected:
             POP_GenVar (OP_Network* net, const char* name, 
                         OP_Operator* entry);
    virtual ~POP_GenVar (void);

    // the birthFrom___ functions birth particles from certain types of 
    // source geometry. 
    //   Points     = birth from points
    //   Primitives = birth from primitives 
    //   MetaPrim   = birth from metaprimitives
    //   Detail     = birth from detail's volume
    //
    //     data                 POP_ContextData being used
    //     doVar                update local variables for source point
    //     gdp                  detail to retrieve geometry from
    //     group                point or primitive group to use (or NULL)
    //     xform                transform to apply to birthed particle position
    //                          (or NULL)
    //     xformv               transform to apply to vector attributes
    //                          (or NULL)
    //     map                  mapping for inheriting attributes.
    //                          The map should correspond to the inherit
    //                          attribute data if it is set, otherwise, it
    //                          should be built for the source gdp.
    //                          (or NULL to do no inheriting).
    //     inherit              attribute data to inherit general attributes
    //                          from. if NULL, then general attributes are
    //                          inherited from the source geo. 
    //     split                attributes from source particle when 
    //                          splitting (or NULL when not splitting).
    //     originIndex          origin index value.
    //     originUse            how to set origin id. Bit mask
    //                              POP_ORIGIN_INDEX: add passed in index
    //                              POP_ORIGIN_GEO: add source geometry number
    //                              POP_ORIGIN_PARENT: add split origin
    //                          source geo number:
    //                              point - pt num
    //                              primitives - primitive num
    //                              metaprim - 0
    //                              detail - 0    
    //     born                 number of points to birth
    //     part                 particle primitive to birth into
    //     birthGroup           group to add birthed points to (or NULL)
    //     lifetime             function that generates a particle lifetime
    //     probability          function that generates a random number
    //                          representing the number of particles to birth
    //                          per point/primitive.
    //     birthAttrib          function to set attributes after particle 
    //                          is birthed
    //     doRandom             if 1, birth from randomized points. if 0,
    //                          birth from points in order
    //     whereFrom            if 1, birth from surface. if 0, birth from edge
    //                          if 2, birth from primitive center
    //     checkTrim            if 1, birth from trimmed area only. 
    //                          if 0, birth from entire surface.
    //     threshold            for metaprim birthing, points are sampled
    //                          and added. Birthin of a particle will occur
    //                          when this threshold is passed.
    //     densityMin           for metaprim birthing, particle will not be
    //                          birthed unless the density is at least this
    //     intersector          a GU_RayIntersect to perform ray intersections
    //                          with the detail. It is the caller's 
    //                          responsibility to make sure that the 
    //                          intersector is initialized.
    //     useDensityProb       use metaball density as a probability
    //                          distribution for particle births. Causes
    //                          threshold parameter to be ignored.
    //     jitter               function to do jitter births
    //     maxAttempts          failure threshold to tolerate before giving up

    void        birthFromPoints (int doVar, POP_ContextData* data, 
                                 GU_Detail* gdp, GB_PointGroup* group,
                                 UT_Matrix4* xform, UT_Matrix3* xformv,
                                 POP_AttribMap* map, 
                                 GB_AttributeData* inherit, 
                                 GB_AttributeData* split, 
                                 POP_IntFunc originIndex, int originUse, 
                                 float* born, GEO_PrimParticle* part,
                                 GB_PointGroup* birthGroup, 
                                 POP_FloatFunc lifetime,
                                 POP_FloatFunc probability,
                                 POP_BirthAttribFunc birthAttrib,
                                 int doRandom,
                                 POP_JitterFunc jitter = 0,
                                 int maxAttempts=100);

    void        birthFromPointVelocity (int doVar, POP_ContextData *data,
                                GU_Detail *gdp, GB_PointGroup *group,
                                UT_Matrix4 *xform, UT_Matrix3 *xformv,
                                POP_AttribMap *map,
                                GB_AttributeData *inherit,
                                GB_AttributeData *split,
                                POP_IntFunc originIndex, int originUse,
                                float *born, GEO_PrimParticle *part,
                                GB_PointGroup *birthGroup,
                                POP_FloatFunc lifetime,
                                POP_BirthAttribFunc birthAttrib,
                                UT_Vector3 birthVelocity,
                                UT_Vector3 birthAcceleration,
                                fpreal velocityScale,
                                fpreal particleSpacing);

    void        birthFromPrimitives (int doVar, POP_ContextData* data, 
                                     GU_Detail* gdp, GB_PrimitiveGroup* group,
                                     UT_Matrix4* xform, UT_Matrix3* xformv,
                                     POP_AttribMap* map,
                                     GB_AttributeData* inherit, 
                                     GB_AttributeData* split, 
                                     POP_IntFunc originIndex, int originUse,
                                     float* born, GEO_PrimParticle* part,
                                     GB_PointGroup* birthGroup, 
                                     POP_FloatFunc lifetime,
                                     POP_FloatFunc probability,
                                     POP_BirthAttribFunc birthAttrib,
                                     int whereFrom, int checkTrim,
                                     POP_JitterFunc jitter = 0,
                                     int doRandom = 0, int maxAttempts = 100);

    void        birthFromMetaPrim  (int doVar, POP_ContextData* data,
                                    GU_Detail* gdp, GB_PrimitiveGroup* group,
                                    UT_Matrix4* xform, UT_Matrix3* xformv,
                                    POP_AttribMap* map, 
                                    GB_AttributeData* inherit, 
                                    GB_AttributeData* split, 
                                    POP_IntFunc originIndex, int originUse,
                                    float* born, GEO_PrimParticle* part,
                                    GB_PointGroup* birthGroup, 
                                    POP_FloatFunc lifetime,
                                    POP_BirthAttribFunc birthAttrib, 
                                    float threshold, float densityMin,
                                    int useDensityProb,
                                    POP_JitterFunc jitter = 0,
                                    int maxAttempts = 100);

    void        birthFromDetail    (int doVar, POP_ContextData* data, 
                                    GU_Detail* gdp,
                                    UT_Matrix4* xform, UT_Matrix3* xformv,
                                    POP_AttribMap* map, 
                                    GB_AttributeData* inherit, 
                                    GB_AttributeData* split, 
                                    POP_IntFunc originIndex, int originUse,
                                    float* born, GEO_PrimParticle* part,
                                    GB_PointGroup* birthGroup, 
                                    POP_FloatFunc lifetime,
                                    POP_BirthAttribFunc birthAttrib,
                                    GU_RayIntersect* intersector,
                                    POP_JitterFunc jitter = 0,
                                    int maxAttempts = 100);

    // the birthNonUniformlyFromRandomPrimitives function births particles 
    // from certain types of source geometry in a non-uniform random manner.
    //
    // All parameters common with the birthFrom__ functions have the same
    // meaning.  In addition, this method supports the following additional
    // parameters.
    // 
    //     distribAttrib - name of the primitive attribute which specifies
    //                     the probability distribution for each primitive.
    //                     The values are normalized and then used as the
    //                     probability that this is the random primitive
    //                     selected to birth from.
    //                     If attribute does not exist, a uniform distribution
    //                     is used by default.
    //                     NOTE: if the value of the attribute for a
    //                           primitive is <= 0, then particles will
    //                           not birth off of that primitive.
    //
    void        birthNonUniformlyFromRandomPrimitives (int doVar, 
                                 POP_ContextData* data, 
                                 GU_Detail* gdp, GB_PrimitiveGroup* group,
                                 UT_Matrix4* xform, UT_Matrix3* xformv,
                                 POP_AttribMap* map,
                                 GB_AttributeData* inherit, 
                                 GB_AttributeData* split, 
                                 POP_IntFunc originIndex, int originUse, 
                                 float* born, GEO_PrimParticle* part,
                                 GB_PointGroup* birthGroup,
                                 POP_FloatFunc lifetime,
                                 POP_FloatFunc probability,
                                 POP_BirthAttribFunc birthAttrib,
                                 int whereFrom, int checkTrim,
                                 POP_JitterFunc jitter,
                                 const UT_String &distribAttrib,
                                 int maxAttempts);


    // buildVectorTransform() builds a matrix that transforms vectors.
    // If xform is used to transform points, then xformv can be
    // applied to transform vectors.
    void                buildVectorTransform (UT_Matrix3& xformv,
                                              const UT_Matrix4& xform);

    virtual float       getVariableValue (int index, int thread);

    void                setupVars       (POP_ContextData* data, 
                                         GU_Detail* gdp,
                                         const GB_Group* source = 0);

    // Jitter births can change the detail being birthed from, consequently
    // obsoleting the underlying attribute data set up with the setupVars()
    // call.  The hasAttributeVars() and refreshAttributeVars() methods below
    // can be used to keep this data updated.
    bool                hasSourceAttributeVars() const;
    void                refreshSourceAttributeVars(GU_Detail *gdp);

    virtual int         isVarDependent  (GU_Detail* gdp, POP_FParam param,
                                         float t, int thread);
    virtual int         isVarDependent  (GU_Detail* gdp, POP_IParam param,
                                         float t, int thread);
    virtual int         isVarDependent  (GU_Detail* gdp, POP_SParam param,
                                         float t, int thread);
    virtual int         isVarDependent  (GU_Detail* gdp, EV_EXPRESSION* expr,
                                         int thread);

    void                allowVar (int val) { myAllowGeneratorVar = val; };
    int                 isAllowVar() const { return myAllowGeneratorVar; }

    int                 isVarTest() const { return myVarTest; }
    void                setVarDependent(int val) { myVarDependent = val; }

    void                clearLastEmissionTime() { myLastEmissionTime = FP32_REAL_MAX; }

    UT_Vector4*         mySourcePos;            // source position 
    GB_AttributeData*   mySourceAtt;            // source attributes 
    int                 mySourceIter;           // iteration number
    float               mySourceU;              // source parametric u 
    float               mySourceV;              // source parametric v
    const GB_Element*   mySourceElem;           // source element
    UT_Vector3*         mySourceNml;            // source normal
   
private:

    void                computeBBox     (void);

    int                 myNumParticles;
    int                 myNumPoints;
    int                 myNumPrims;
    int                 myNumGroupEntries;
    GU_Detail*          myBBGdp;
    UT_Vector3          myBBOrigin;
    UT_Vector3          myBBScale;
    float               myTimeInc;

    // Store the last emission time - used for birthing particles with
    // a constant separation based on their outgoing velocity.
    fpreal              myLastEmissionTime;

    int                 myAllowGeneratorVar;
    int                 myVarDependent;
    int                 myVarTest;

    int                 myAlphaOffset;
    int                 myDiffuseOffset;
    int                 myDistanceOffset;
    int                 myDragOffset;
    int                 myMassOffset;
    int                 myNormalOffset;
    int                 myScaleOffset;
    int                 mySpringKOffset;
    int                 myTensionOffset;
    int                 myTextureOffset;
    int                 myUpOffset;
    int                 myVelocityOffset;
};

#endif

---