SOP_Expand.C

Go to the documentation of this file.

/*
 * Copyright (c) 2025
 *      Side Effects Software Inc.  All rights reserved.
 *
 * Redistribution and use of Houdini Development Kit samples in source and
 * binary forms, with or without modification, are permitted provided that the
 * following conditions are met:
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. The name of Side Effects Software may not be used to endorse or
 *    promote products derived from this software without specific prior
 *    written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE `AS IS' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
 * NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *----------------------------------------------------------------------------
 * The HDK Expand SOP
 */

#include "SOP_Expand.h"

// This is an automatically generated header file based on theDsFile, below,
// to provide SOP_ExpandParms, an easy way to access parameter values from
// SOP_ExpandVerb::cook with the correct type.
#include "SOP_Expand.proto.h"

#include <GA/GA_ElementGroup.h>
#include <GU/GU_Detail.h>
#include <GU/GU_Selection.h>
#include <GEO/GEO_Closure.h>
#include <GOP/GOP_Manager.h>
#include <OP/OP_Operator.h>
#include <OP/OP_OperatorTable.h>
#include <PRM/PRM_Include.h>
#include <PRM/PRM_TemplateBuilder.h>
#include <UT/UT_DSOVersion.h>
#include <UT/UT_StringHolder.h>


using namespace UT::Literal;
using namespace HDK_Sample;

//
// Help is stored in a "wiki" style text file.  This text file should be copied
// to $HOUDINI_PATH/help/nodes/sop/hdk_expand.txt
//
// See the sample_install.sh file for an example.
//

/// This is the internal name of the SOP type.
/// It isn't allowed to be the same as any other SOP's type name.
const UT_StringHolder SOP_Expand::theSOPTypeName("hdk_expand"_sh);

/// newSopOperator is the hook that Houdini grabs from this dll
/// and invokes to register the SOP.  In this case, we add ourselves
/// to the specified operator table.
void
newSopOperator(OP_OperatorTable *table)
{
    table->addOperator(new OP_Operator(
        SOP_Expand::theSOPTypeName,   // Internal name
        "HDK Expand",                     // UI name
        SOP_Expand::myConstructor,    // How to build the SOP
        SOP_Expand::buildTemplates(), // My parameters
        1,                          // Min # of sources
        1,                          // Max # of sources
        nullptr,                    // Custom local variables (none)
        0,                          // No flags, not a generator, no merge input, not an output node.
        0,                          // Not supplying custom input labels here.
        1,                          // One output
        "HDK Examples"));              // Make the SOP appear in the HDK Examples tab submenu
}

/// This is a multi-line raw string specifying the parameter interface
/// for this SOP.

// For our purpose we will customize the string input parameter to
// more easily input the group.
// In SOP_Expand::buildTemplates we bind a drop down menu to the group field.
// Next, to get a selector button we use the 'script_action' parmtag to
// specify the script to execute when the button is pressed, the
// 'script_action_help' parmtag to create the hover tooltip, and the
// 'script_action_icon' parmtag to set the icon.
// All group selector buttons use the `soputils.selectGroupParm(kwargs)`
// function, and can use the kwargs['geometrytype'] to set the allowed
// geometry types, and the kwargs['indexindex'] to set the input
// to select on.
// Notice that we are able to pass a parameter to the kwargs['geometrytype'].
// If this is done the selector will treat the allowable menu options as
// the acceptable group types and will change the menu to the
// chosen group type when the selection has been accepted.
static const char *theDsFile = R"THEDSFILE(
{
    name        parameters
    parm {
        name    "group"
        label   "Group"
        type    string
        default { "" }
        parmtag { "script_action" "import soputils\nkwargs['geometrytype'] = kwargs['node'].parmTuple('grouptype')\nkwargs['inputindex'] = 0\nsoputils.selectGroupParm(kwargs)" }
        parmtag { "script_action_help" "Select geometry from an available viewport.\nShift-click to turn on Select Groups." }
        parmtag { "script_action_icon" "BUTTONS_reselect" }
    }
    parm {
        name    "grouptype"
        label   "Group Type"
        type    ordinal
        default { "0" }
        menu    {
            "points"    "Points"
            "prims"     "Primitives"
        }
    }
    parm {
        name    "scale"
        label   "Uniform Scale"
        type    float
        default { "1" }
        range   { 0! 10 }
    }
}
)THEDSFILE";

PRM_Template*
SOP_Expand::buildTemplates()
{
    static PRM_TemplateBuilder templ("SOP_Expand.C"_sh, theDsFile);

    if (templ.justBuilt())
    {
        // Add drop down menu to the attribute string field.
        // The menu type is a PRM_ChoiceList and SOP_Node provides a
        // number of nice pre-built menus that you can use.

        // In this case we want to list all the primitive groups on the
        // second input. We can use SOP_Node::groupMenu to generate the
        // menu for us which will list all point
        // and primitive groups.
        templ.setChoiceListPtr("group", &SOP_Node::groupMenu);
    }

    return templ.templates();
}

// Define the verb for this SOP Node.
class SOP_ExpandVerb : public SOP_NodeVerb
{
public:
    SOP_ExpandVerb() {}
    virtual ~SOP_ExpandVerb() {}

    virtual SOP_NodeParms *allocParms() const { return new SOP_ExpandParms(); }
    virtual UT_StringHolder name() const { return SOP_Expand::theSOPTypeName; }

    // There are a few choices for the cookMode.
    // For SOPs with no inputs that only generate geometry use COOK_GENERATOR
    // For SOPs that modify the input, COOK_DUPLICATE or COOK_INPLACE is usually
    // the best option, with COOK_DUPLICATE creating a full copy of the input detail
    // and COOK_INPLACE working on the input detail directly.
    // The final option COOK_GENERIC allows any number of inputs, but the detail you
    // get in ::cook will be empty by default. This mode is useful for SOPs like Sweep
    // that combine two separate geometries in an interesting way.
    virtual CookMode cookMode(const SOP_NodeParms *parms) const { return COOK_INPLACE; }

    virtual void cook(const CookParms &cookparms) const;

    /// This static data member automatically registers
    /// this verb class at library load time.
    static const SOP_NodeVerb::Register<SOP_ExpandVerb> theVerb;
};

// The static member variable definition has to be outside the class definition.
// The declaration is inside the class.
const SOP_NodeVerb::Register<SOP_ExpandVerb> SOP_ExpandVerb::theVerb;

// The ::cookVerb member on the node must return an instance of the class
// we just defined above.
const SOP_NodeVerb *
SOP_Expand::cookVerb() const 
{ 
    return SOP_ExpandVerb::theVerb.get();
}

/// This is the function that does the actual work.
void
SOP_ExpandVerb::cook(const SOP_NodeVerb::CookParms &cookparms) const
{
    auto &&sopparms = cookparms.parms<SOP_ExpandParms>();

    // The destination detail.
    GU_Detail *detail = cookparms.gdh().gdpNC();

    // Get the input group pattern, grouptype and the scale.
    UT_StringHolder groupname = sopparms.getGroup();
    // When the proto file is generated, it will automatically
    // generate enums for the different options in menus.
    SOP_ExpandEnums::Grouptype grouptype = sopparms.getGrouptype();
    fpreal scale = sopparms.getScale();

    // NOTE: Any detached groups created by the GOP_Manager
    // get deleted when the GOP_Manager is destroyed.
    GOP_Manager gop;
    const GA_PointGroup * point_group = nullptr;
    const GA_PrimitiveGroup * prim_group = nullptr;

    // If the input group type is primitives then we will parse the group
    // as a primitive group and get the point group closure of it as a
    // detached group. To ensure this group gets deleted when we're done
    // with it we use a detached group returned as a unique pointer which
    // will destroy the group when this unique pointer gets destroyed.
    GA_PointGroupUPtr point_group_closure = nullptr;
    if (groupname.isstring())
    {
        // To parse the group the GOP Manager needs at minimum the
        // group string and the detail on which to create the groups.

        // We create a light wrapper around the detail with the
        // GOP_Manager::GroupCreator. The wrapper is used to provide
        // a common interface to GEO_Detail when using a const or
        // non-const detail. If the detail is constant then any
        // created group is detached, and if the detail is not
        // constant then you have a choice when creating the
        // GroupCreator whether to create detached groups or not.
        GOP_Manager::GroupCreator group_creator(detail, /*detached=*/true);
        switch (grouptype) {
            case SOP_ExpandEnums::Grouptype::POINTS:
            {
                // Parse the group as points.
                point_group = gop.parsePointGroups(groupname, group_creator);
                break;
            }
            case SOP_ExpandEnums::Grouptype::PRIMS:
            {
                // Parse the group as prims and promote to points.
                // We'll want to continue holding onto prim_group to set the
                // cook selection later as well.
                prim_group = gop.parsePrimitiveGroups(groupname, group_creator);

                if (prim_group)
                {
                    // Use the GEO_Closure functions to get a detached point group
                    // containing all points on the input primitives.
                    // This is owned by this unique pointer and when this unique
                    // pointer is destroyed, the group will also be destroyed.
                    point_group_closure = GEO_Closure::getDetachedPointClosure(*detail, *prim_group);
                    point_group = point_group_closure.get();
                }
                break;
            }
        }

        // If the returned group is nullptr then it could not parse
        // the input string.
        if (!point_group)
            cookparms.sopAddWarning(SOP_ERR_BADGROUP, groupname);
    }
    // Get the range of points to look at.
    // If point_group is nullptr, this will give a point range
    // with all points in the detail.
    GA_Range point_range = detail->getPointRange(point_group);

    // Compute the centroid position by averaging the point positions.
    UT_Vector3D centroid(0,0,0);
    for (GA_Offset pt_off : point_range)
    {
        // Get the point position with GA_Detail::getPos3D.
        const UT_Vector3D pos = detail->getPos3D(pt_off);
        centroid += pos;
    }

    if (!point_range.isEmpty())
        centroid /= point_range.getEntries();

    // Now scale the point positions with respect to the centroid.
    for (GA_Offset pt_off : point_range)
    {
        // Get the point position with GA_Detail::getPos3D.
        UT_Vector3D pos = detail->getPos3D(pt_off);

        // First subtract the centroid position to get the offset from the centroid.
        pos -= centroid;
        // Then scale the offset from the centroid by the uniform scale.
        pos *= scale;
        // Then add the centroid position back in.
        pos += centroid;

        // And finally set the point position using GA_Detail::setPos3.
        detail->setPos3(pt_off, pos);
    }

    // Set up a cook selection to show all the affected points/prims.
    if (cookparms.selectionEnabled())
    {
        // We want the cook selection to match the input group type.
        switch (grouptype) {
            case SOP_ExpandEnums::Grouptype::POINTS:
            {
                // If we have a point group, set the cook selection to the point group
                // Otherwise, set the cook selection to all points in the detail.
                if (point_group)
                    cookparms.select(*point_group);
                else
                    cookparms.select(GA_GROUP_POINT);
                break;
            }
            case SOP_ExpandEnums::Grouptype::PRIMS:
            {
                // If we have a prim group, set the cook selection to the prim group.
                // Otherwise, set the cook selection to all prims in the detail.
                if (prim_group)
                    cookparms.select(*prim_group);
                else
                    cookparms.select(GA_GROUP_PRIMITIVE);
                break;
            }
        }
    }

    // We have modified the 'P' attribute so we need to bump its data id.
    // To bump all data ids you can use detail->bumpAllDataIds();
    // For our case we only modified a single attribute so we can just bump
    // that one attribute's data ids.
    detail->getP()->bumpDataId();
}