SOP_MaxPromote.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 MaxPromote SOP
 */

#include "SOP_MaxPromote.h"

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

#include <GU/GU_Detail.h>
#include <GU/GU_Promote.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_maxpromote.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_MaxPromote::theSOPTypeName("hdk_maxpromote"_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_MaxPromote::theSOPTypeName,   // Internal name
        "HDK Max Promote",                     // UI name
        SOP_MaxPromote::myConstructor,    // How to build the SOP
        SOP_MaxPromote::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,                          // No custom input labels
        1,                          // One output
        "HDK Examples"));              // Make the SOP appear in the Attribute tab submenu
}

/// This is a multi-line raw string specifying the parameter interface
/// for this SOP.
static const char *theDsFile = R"THEDSFILE(
{
    name        parameters
    parm {
        name    "attrib"
        label   "Point Attribute"
        type    string
        default { "" }
    }
    parm {
        name    "keepsource"
        label   "Keep Source Attribute"
        type    toggle
        default { "1" }
    }
}
)THEDSFILE";

PRM_Template*
SOP_MaxPromote::buildTemplates()
{
    static PRM_TemplateBuilder templ("SOP_MaxPromote.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. For our case
        // we would like to list all of the point attributes so we can
        // choose between 'pointAttribMenu' or 'pointAttribReplaceMenu'
        // for whether we want a toggle or a replace menu.
        // Since the SOP only handles one attribute name, the
        // SOP_Node::pointAttribReplaceMenu is the best choice.
        templ.setChoiceListPtr("attrib", &SOP_Node::pointAttribReplaceMenu);
    }

    return templ.templates();
}

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

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

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

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

template <typename T>
void
sopPromote(const SOP_NodeVerb::CookParms &cookparms,
           GU_Detail & detail,
           const GA_Attribute & source_attrib,
           GA_Attribute & dest_attrib)
{
    // Use a read-only handle for the source attribute.
    GA_ROHandleT<T> source_handle(&source_attrib);

    // Ensure the source handle got bound correctly.
    if (source_handle.isInvalid())
    {
        cookparms.sopAddError(SOP_MESSAGE, "Unable to bind read-only handle to source attribute.");
        return;
    }

    // Use a read-write handle for the dest attribute.
    GA_RWHandleT<T> dest_handle(&dest_attrib);

    // Ensure dest_handle got bound correctly.
    if (dest_handle.isInvalid())
    {
        cookparms.sopAddError(SOP_MESSAGE, "Unable to bind read-write handle to output attribute.");
        return;
    }

    // Scan all the points, find the maximal value.
    // If there are no points, then max_val will get the value 0.
    T max_val = 0;
    T cur_val = 0;
    bool first_set = false;
    for (GA_Offset pt_off : detail.getPointRange())
    {
        cur_val = source_handle.get(pt_off);
        if (!first_set || cur_val > max_val)
        {
            first_set = true;
            max_val = cur_val;
        }
    }

    // Store the max into the detail attribute.
    dest_handle.set(GA_DETAIL_OFFSET, max_val);
}

/// This is the function that does the actual work.
void
SOP_MaxPromoteVerb::cook(const SOP_NodeVerb::CookParms &cookparms) const
{
    auto &&sopparms = cookparms.parms<SOP_MaxPromoteParms>();
    GU_Detail *detail = cookparms.gdh().gdpNC();

    // Get the attribute name.
    UT_StringHolder attrib_name = sopparms.getAttrib();

    // Find the attribute, if not valid then display a warning.
    GA_Attribute * source_attrib = detail->findPointAttribute(attrib_name);
    if (!source_attrib)
    {
        // There are a number of common error messages you can use defined in
        // SOP_Error.h. The SOP_ATTRIBUTE_INVALID will take the attribute's
        // name and format a warning for us that the attribute is not valid.
        cookparms.sopAddWarning(SOP_ATTRIBUTE_INVALID, attrib_name);
        return;
    }

    bool keep_existing = sopparms.getKeepsource();

    // NOTE: All of the following can be done more efficiently and with more
    // generality using GU_Promote::promote.
    // GU_Promote::promote(
    //     /*gdp=*/*detail,                        // The geometry detail to modify
    //     /*attrib=*/source_attrib,               // The source attribute to promote
    //     /*new_owner=*/GA_ATTRIB_DETAIL,         // Promote to detail
    //     /*destroy_existing=*/!keep_existing,    // Drive from "keepsource" toggle.
    //     /*method=*/GU_Promote::GU_PROMOTE_MAX,  // Use max promotion method
    //     /*new_name=*/nullptr,                   // Keep existing name
    //     /*piece_attrib=*/nullptr);              // No point attribute

    GA_ATINumeric * source_numerical_attrib = GA_ATINumeric::cast(source_attrib);
    if (!source_numerical_attrib || source_numerical_attrib->getTupleSize() != 1)
    {
        // SOP_MESSAGE allows you to specify any custom message to display
        // as either a warning using cookparms.sopAddWarning or an error
        // using cookparms.sopAddError.
        cookparms.sopAddError(SOP_MESSAGE, "Invalid attribute type. Only numerical attributes with one component are supported.");
        return;
    }

    // Destroy any existing attribute on the detail with the same name.
    detail->destroyAttribute(GA_ATTRIB_GLOBAL, source_attrib->getName());

    // Clone the source attribute but set the owner to the detail so we get the
    // output attribute with the same storage type, options, tuple size,
    // and scope.
    GA_Attribute * out_attrib = detail->getAttributes().cloneAttribute(
            /*owner=*/GA_ATTRIB_GLOBAL,
            /*name=*/source_attrib->getName(),
            /*src=*/*source_attrib,
            /*clone_options=*/true);
    if (!out_attrib)
    {
        cookparms.sopAddError(SOP_MESSAGE, "Failed to create output attribute.");
        return;
    }

    // Delegate the promotion to a templated function based on the storage type.
    // We can read and write to attributes using a GA_ROHandleT<> (write only)
    // or a GA_RWHandleT<> (read+write). There are a number of
    // common handles defined in GA_Handle.h.
    switch (source_numerical_attrib->getStorage())
    {
        case GA_STORE_INT32:
        {
            // Use a GA_ROHandleI and GA_RWHandleI
            sopPromote<int32>(cookparms, *detail, *source_attrib, *out_attrib);
            break;
        }
        case GA_STORE_INT64:
        {
            // Use a GA_ROHandleID and GA_RWHandleID
            sopPromote<int64>(cookparms, *detail, *source_attrib, *out_attrib);
            break;
        }
        case GA_STORE_REAL32:
        {
            // Use a GA_ROHandleF and GA_RWHandleF
            sopPromote<fpreal32>(cookparms, *detail, *source_attrib, *out_attrib);
            break;
        }
        case GA_STORE_REAL64:
        {
            // Use a GA_ROHandleD and GA_RWHandleD
            sopPromote<fpreal64>(cookparms, *detail, *source_attrib, *out_attrib);
            break;
        }
        default:
        {
            cookparms.sopAddError(SOP_MESSAGE, "Invalid attribute storage type. Only 32 and 64 bit integer or floating point attributes are supported.");
            return;
        }
    }

    // Destroy existing if specified.
    if (!keep_existing)
    {
        detail->destroyAttribute(source_attrib->getOwner(), source_attrib->getName());
    }

    // NOTE: Whenever an existing attribute is modified, you must bump the data
    // IDs on the attribute to ensure the various parts of houdini know that
    // the attribute, and the detail it is on, have changed.
    // To bump a single attribute data Id, you can call GA_Attribute::bumpDataId(),
    // and to bump all attribute data Ids on a detail you can call
    // GA_Detail::bumpAllDataIds().
    // In this case, we are not modifying any existing attributes so we are okay,
    // but the regular SOP Attribute Promote using GU_Promote::promote *may* alter
    // existing attributes, and will automatically call GA_Attribute::bumpDataId().
}