Jump to content
amin.khormaei

some basic question about SOP_PointWave Example code

Recommended Posts

hello everyone,i'm learning c++ and I'm new to Houdini HDK.

I was reading another topic, someone told that you can use example files and manipulate them.

so I have some questions for you:

as you can see the header code and it's definition

namespace HDK_Sample {
/// Run a sin() wave through geometry by deforming points
/// @see @ref HOM/SOP_HOMWave.C, SOP_HOMWave, SOP_CPPWave
class SOP_PointWave : public SOP_Node
{
public:
             SOP_PointWave(OP_Network *net, const char *name, OP_Operator *op);
    virtual ~SOP_PointWave();
    static PRM_Template          myTemplateList[];
    static OP_Node              *myConstructor(OP_Network*, const char *,
                                                            OP_Operator *);
    /// This method is created so that it can be called by handles.  It only
    /// cooks the input group of this SOP.  The geometry in this group is
    /// the only geometry manipulated by this SOP.
    virtual OP_ERROR             cookInputGroups(OP_Context &context, 
                                                int alone = 0);
protected:
    /// Method to cook geometry for the SOP
    virtual OP_ERROR             cookMySop(OP_Context &context);
private:
    void        getGroups(UT_String &str){ evalString(str, "group", 0, 0); }
    fpreal      AMP(fpreal t)           { return evalFloat("amp", 0, t); }
    fpreal      PHASE(fpreal t)         { return evalFloat("phase", 0, t); }
    fpreal      PERIOD(fpreal t)        { return evalFloat("period", 0, t); }
    /// This is the group of geometry to be manipulated by this SOP and cooked
    /// by the method "cookInputGroups".
    const GA_PointGroup *myGroup;
};
using namespace HDK_Sample;
void
newSopOperator(OP_OperatorTable *table)
{
    table->addOperator(new OP_Operator(
        "hdk_pointwave",
        "Point Wave",
        SOP_PointWave::myConstructor,
        SOP_PointWave::myTemplateList,
        1,
        1,
        0));
}
static PRM_Name names[] = {
    PRM_Name("amp",     "Amplitude"),
    PRM_Name("phase",   "Phase"),
    PRM_Name("period",  "Period"),
};
PRM_Template
SOP_PointWave::myTemplateList[] = {
    PRM_Template(PRM_STRING,    1, &PRMgroupName, 0, &SOP_Node::pointGroupMenu,
                                0, 0, SOP_Node::getGroupSelectButton(
                                                GA_GROUP_POINT)),
    PRM_Template(PRM_FLT_J,     1, &names[0], PRMoneDefaults, 0,
                                   &PRMscaleRange),
    PRM_Template(PRM_FLT_J,     1, &names[1], PRMzeroDefaults),
    PRM_Template(PRM_FLT_J,     1, &names[2], PRMoneDefaults),
    PRM_Template(),
};
OP_Node *
SOP_PointWave::myConstructor(OP_Network *net, const char *name, OP_Operator *op)
{
    return new SOP_PointWave(net, name, op);
}
SOP_PointWave::SOP_PointWave(OP_Network *net, const char *name, OP_Operator *op)
    : SOP_Node(net, name, op), myGroup(NULL)
{
   
    mySopFlags.setManagesDataIDs(true);
}
SOP_PointWave::~SOP_PointWave() {}
OP_ERROR
SOP_PointWave::cookInputGroups(OP_Context &context, int alone)
{
    
    return cookInputPointGroups(
        context, // This is needed for cooking the group parameter, and cooking the input if alone.
        myGroup, // The group (or NULL) is written to myGroup if not alone.
        alone,   // This is true iff called outside of cookMySop to update handles.
                 // true means the group will be for the input geometry.
                 // false means the group will be for gdp (the working/output geometry).
        true,    // (default) true means to set the selection to the group if not alone and the highlight flag is on.
        0,       // (default) Parameter index of the group field
        -1,      // (default) Parameter index of the group type field (-1 since there isn't one)
        true,    // (default) true means that a pointer to an existing group is okay; false means group is always new.
        false,   // (default) false means new groups should be unordered; true means new groups should be ordered.
        true,    // (default) true means that all new groups should be detached, so not owned by the detail;
                 //           false means that new point and primitive groups on gdp will be owned by gdp.
        0        // (default) Index of the input whose geometry the group will be made for if alone.
    );
}
OP_ERROR
SOP_PointWave::cookMySop(OP_Context &context)
{
    
    OP_AutoLockInputs inputs(this);
    if (inputs.lock(context) >= UT_ERROR_ABORT)
        return error();
   
    duplicatePointSource(0, context);
    fpreal t = context.getTime();
    
    float phase = PHASE(t);
    float amp = AMP(t);
    float period = PERIOD(t);
    if (error() >= UT_ERROR_ABORT)
        return error();
    
    if (cookInputGroups(context) >= UT_ERROR_ABORT)
        return error();
    GA_Offset ptoff;
    GA_FOR_ALL_GROUP_PTOFF(gdp, myGroup, ptoff)
    {
        UT_Vector3 p = gdp->getPos3(ptoff);
        p.y() += SYSsin( (p.x() / period + phase) * M_PI * 2 ) * amp;
        gdp->setPos3(ptoff, p);
    }
   
    if (!myGroup || !myGroup->isEmpty())
        gdp->getP()->bumpDataId();
    return error();
}

my first question is:

we have this int header file :

 SOP_PointWave(OP_Network *net, const char *name, OP_Operator *op);

where is it's definition in *.c file?

-----------------------------------------------------------------------------------------------------------------------------------------

 

my second question is:

void
newSopOperator(OP_OperatorTable *table)
{
    table->addOperator(new OP_Operator(
        "hdk_pointwave",
        "Point Wave",
        SOP_PointWave::myConstructor,
        SOP_PointWave::myTemplateList,
        1,
        1,
        0));
}

why this function is void?  I know because it won't return anything, but why it shouldn't?

why newSopOperator's parameter is a class (i know a class is custom data type) but why?

and what is table in the parameter?

 

-----------------------------------------------------------------

BEST REGARDS

 

Share this post


Link to post
Share on other sites

To be honest, you've chosen the wrong place to ask basic C++ questions.

1. Look closer and you'll find the definition in the C file.

2. What do you expect it to return and why? This is your plugin entry point, Houdini calls it to register your new operator.

 

P.S. Learning C++ via HDK is a very wrong strategy imo. :) 

  • Like 1

Share this post


Link to post
Share on other sites
52 minutes ago, Stalkerx777 said:

To be honest, you've chosen the wrong place to ask basic C++ questions.

1. Look closer and you'll find the definition in the C file.

2. What do you expect it to return and why? This is your plugin entry point, Houdini calls it to register your new operator.

 

P.S. Learning C++ via HDK is a very wrong strategy imo. :) 

Thank you for your explicit answer

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

×