SOP_MinRay.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 Minimum Ray SOP
 */

#include "SOP_MinRay.h"

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

#include <GA/GA_ElementGroup.h>
#include <GA/GA_SplittableRange.h>
#include <GU/GU_Detail.h>
#include <GU/GU_RayIntersect.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 thePointsInput = 0;
constexpr static int theSurfaceInput = 1;

//
// 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_MinRay::theSOPTypeName("hdk_minray"_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_MinRay::theSOPTypeName,   // Internal name
        "HDK Minimum Ray",                     // UI name
        SOP_MinRay::myConstructor,    // How to build the SOP
        SOP_MinRay::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.
        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_MinRay::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.
static const char *theDsFile = R"THEDSFILE(
{
    name        parameters
    parm {
        name    "group"
        label   "Group"
        type    string
        default { "" }
        parmtag { "script_action" "import soputils\nkwargs['geometrytype'] = (hou.geometryType.Points,)\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" }
    }
}
)THEDSFILE";

PRM_Template*
SOP_MinRay::buildTemplates()
{
    static PRM_TemplateBuilder templ("SOP_MinRay.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::pointGroupMenu);
    }

    return templ.templates();
}

// Set custom input labels for the source and destination inputs.
const char *
SOP_MinRay::inputLabel(OP_InputIdx idx) const
{
    switch (idx)
    {
        case thePointsInput:
            return "Ray Points";
        case theSurfaceInput:
            return "Collision Geometry";
        default:
            return "Invalid Source";
    }
}

// Build the cache. We use this to store structures computed
// for the surface geometry that let us very quickly find the
// hits. This means that as long as the surface geometry
// stays the same, we can keep using these acceleration
// structures so that successive cooks are very fast.
class SOP_MinRayCache : public SOP_NodeCache
{
public:
    SOP_MinRayCache() : myRayIntersect{nullptr} {}

    ~SOP_MinRayCache() override {}

    UT_UniquePtr<GU_RayIntersect> myRayIntersect;
};

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

    ~SOP_MinRayVerb() override {}

    SOP_NodeParms *allocParms() const override { return new SOP_MinRayParms(); }

    // This is needed when we have a node cache.
    SOP_NodeCache *allocCache() const override { return new SOP_MinRayCache(); }

    UT_StringHolder name() const { return SOP_MinRay::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.
    CookMode cookMode(const SOP_NodeParms *parms) const { return COOK_INPLACE; }

    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_MinRayVerb> theVerb;
};

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

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

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

    // Get the node cache.
    SOP_MinRayCache *cache = (SOP_MinRayCache *)cookparms.cache();

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

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

    // Check if the cache data is no longer valid and recreate it
    // if necessary.
    // The call to GU_RayIntersect::validForDetail will check if
    // collision_detail->getUniqueId() and collision_detail->getMetaCacheCount()
    // have not changed since the GU_RayIntersect instance was created.
    if (!cache->myRayIntersect || !cache->myRayIntersect->validForDetail(collision_detail))
    {
        cache->myRayIntersect = UTmakeUnique<GU_RayIntersect>(collision_detail);
    }

    // Get the input group pattern, grouptype and the scale.
    UT_StringHolder groupname = sopparms.getGroup();

    // Parse the group.
    const GA_PointGroup * group = nullptr;
    GOP_Manager gop;
    if (groupname.isstring())
    {
        // Parse the point group.
        group = gop.parsePointGroups(groupname, GOP_Manager::GroupCreator(detail));

        // If we have a group name but no group then it did not parse correctly.
        if (!group)
            cookparms.sopAddWarning(SOP_ERR_BADGROUP, groupname);
    } 

    // NOTE: GA_SplittableRange is guaranteed to give sub-ranges that do not
    // cross the page boundaries. Therefore if we are only writing to
    // point attributes, we will not end up crossing any page boundaries
    // and so we can safely write to the attribute.
    // If however we wanted to allow two threads to write to the same
    // page (i.e. iterating over prims but writing to point attributes),
    // then we will need to harden any of these pages that may get
    // accessed by separate threads. This can be quite costly so
    // it is best to avoid if possible, and also best to harden only
    // a specific range of pages and not all of them.
    UTparallelFor(
        GA_SplittableRange(detail->getPointRange(group)),
        [&](const GA_Range &r)
    {
        // For efficiency we can iterate through the range in blocks
        // and then use a simple for loop within each block.
        GA_Offset start, end;
        for (GA_Iterator it(r); it.blockAdvance(start, end);)
        {
            for (GA_Offset pt = start; pt < end; ++pt)
            {
                // Get the source point position.
                UT_Vector3 pos = detail->getPos3(pt);

                // Ray the position onto the collision geometry.
                // The hit information is then collected in min_info.
                GU_MinInfo min_info;
                exint nhit = cache->myRayIntersect->minimumPoint(pos, min_info);

                // Get the primitive that was hit, if any.
                GEO_ConstPrimitiveP hit_prim = min_info.prim;

                // If not hit, skip it and leave the point where it is.
                if (nhit <= 0)
                    continue;

                // Get the u,v,w coords of the hit in the interior of the prim
                float u = min_info.u1;
                float v = min_info.v1;
                float w = min_info.w1;

                // GU_RayIntersect returns real coordinates not unit
                // coordinates so we need to convert to unit coordinates
                // which evaluateInteriorPoint expects.
                cache->myRayIntersect->fixBrokenUVs(hit_prim, u, v);

                // Evaluate the position at the interior of the prim
                // given the u,v,w coordinates.
                UT_Vector4 out_pos4;
                hit_prim->evaluateInteriorPoint(out_pos4, u, v, w);

                // Finally set the point position to our hit position.
                detail->setPos3(pt, UT_Vector3(out_pos4));
            }
        }
    });

    // 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();
}