SOP_MergePrimitives.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 Merge Primitives SOP
 */

#include "SOP_MergePrimitives.h"

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

#include <GA/GA_ElementGroup.h>
#include <GU/GU_Detail.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;

constexpr static int theDestInput = 0;
constexpr static int theSrcInput = 1;

//
// Help is stored in a "wiki" style text file.  This text file should be copied
// to $HOUDINI_PATH/help/nodes/sop/hdk_simplemerge.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_MergePrimitives::theSOPTypeName("hdk_mergeprimitives"_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_MergePrimitives::theSOPTypeName,   // Internal name
        "HDK Merge Primitives",                     // UI name
        SOP_MergePrimitives::myConstructor,    // How to build the SOP
        SOP_MergePrimitives::buildTemplates(), // My parameters
        2,                          // Min # of sources
        2,                          // 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. See SOP_MergePrimitives::inputLabel.
        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 only need the primitive group, but we will customize
// the string input parameter to more easily input the group.
// This group is on the second input. In SOP_MergePrimitives::buildTemplates
// we bind a drop down menu to the group field. In order to get the menu
// to gather the gro ups on the second input we must specify the
// 'sop_input' parmtag to index '1'.
// 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.
static const char *theDsFile = R"THEDSFILE(
{
    name        parameters
    parm {
        name    "group"
        label   "Primitive Group"
        type    string
        default { "" }
        parmtag { "sop_input" "1" }
        parmtag { "script_action" "import soputils\nkwargs['geometrytype'] = (hou.geometryType.Primitives,)\nkwargs['inputindex'] = 1\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" }
    }
}
)THEDSFILE";

PRM_Template*
SOP_MergePrimitives::buildTemplates()
{
    static PRM_TemplateBuilder templ("SOP_MergePrimitives.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::primGroupMenu to generate
        // the menu for us, and use the `parmtag` `sop_input` with an
        // index of 1 to specify the menu to gather the groups on the
        // input with index 1. Since the inputs are 0-indexed the first
        // input has an index of 0 and the second has an index of 1.
        templ.setChoiceListPtr("group", &SOP_Node::primGroupMenu);
    }

    return templ.templates();
}

// Set custom input labels for the source and destination inputs.
const char *
SOP_MergePrimitives::inputLabel(OP_InputIdx idx) const
{
    switch (idx)
    {
        case theDestInput:
            return "Destination Geometry";
        case theSrcInput:
            return "Source Geometry";
        default:
            return "Invalid Source";
    }
}

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

    virtual SOP_NodeParms *allocParms() const { return new SOP_MergePrimitivesParms(); }
    virtual UT_StringHolder name() const { return SOP_MergePrimitives::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_MergePrimitivesVerb> theVerb;
};

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

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

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

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

    // Get the second input for the source detail.
    const GU_Detail * src_detail = cookparms.inputGeo(theSrcInput);

    // Get the input group pattern.
    UT_StringHolder groupname = sopparms.getGroup();

    // NOTE: Any detached groups created by the GOP_Manager
    // get deleted when the GOP_Manager is destroyed.
    // Since the source detail is const, the groups created
    // WILL be detached and so will be destroyed at the
    // end of this scope when 'gop' is destroyed.
    GOP_Manager gop;

    // Parse the primitive group from the supplied string.
    // If the string is empty then leave the group as nullptr.
    const GA_PrimitiveGroup * group = 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.
        group = gop.parsePrimitiveGroups(
            /*pat=*/groupname,
            /*creator=*/GOP_Manager::GroupCreator(/*detail=*/src_detail));

        // If the returned group is nullptr then it could not parse
        // the input string.
        // If this happens merge the whole detail and show a warning
        // saying that the group was not valid.
        if (!group)
        {
            cookparms.sopAddWarning(SOP_ERR_BADGROUP, groupname);
        }
    }

    // GEO_Detail::merge to merge the primitives in the source detail into
    // the destination detail. If the group field was left blank then
    // nullptr is given to the primGrp input resulting in all primitives
    // being copied.
    // There are a few different ways you are able to merge geometry.
    // 1. GEO_Detail::merge with a detail and a group can be used to merge a
    //    full detail or a group of primitives.
    // 2. GEO_Detail::mergePrimitives can be used to merge only a selection
    //    of primitives defined by a GA_Range.
    // 3. GEO_Detail::mergePoints with a detail and a group can be used to
    //    merge only a group of points.
    // 4. GEO_Detail::mergePoints with a detail and a GA_Range can be used to
    //    merge only a range of points.
    // 5. GEO_Detail::merge with only a GEO_Primitive can be used to merge
    //    a single primitive from the source detail.
    // Note: The GEO_Detail::mergePoints member functions will ONLY merge the
    // points from the source and not the primitives.
    detail->merge(/*src=*/*src_detail, /*primGrp=*/group);
}