GU_AgentMLSkinDeformer.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 */

#ifndef __GU_AgentMLSkinDeformer__
#define __GU_AgentMLSkinDeformer__

#include "GU_API.h"

#include "GU_AgentBlendShapeDeformer.h"
#include "GU_AgentShapeDeformer.h"
#include "GU_AgentShapeLib.h"

#include <SYS/SYS_Types.h>
#include <UT/UT_BoundingBox.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_Span.h>
#include <UT/UT_UniquePtr.h>

/// Agent shape deformer used for ML-driven skin deformation.
class GU_API GU_AgentMLSkinDeformer : public GU_AgentShapeDeformer
{
public:
    GU_AgentMLSkinDeformer();
    ~GU_AgentMLSkinDeformer() override;

    UT_NON_COPYABLE(GU_AgentMLSkinDeformer);

    void
    deform(GU_Detail &gdp, const GU_AgentShapeLib::Shape &src_shape,
           exint xform_idx, const GU_Agent &src_agent) const override;

    void
    computeBounds(UT_BoundingBox &box, const GU_AgentShapeLib::Shape &src_shape,
                  exint xform_idx, const GU_Agent &src_agent) const override;

private:
    GU_AgentBlendShapeDeformer myBlendShapeDeformer;
};

/// Caches data from the agent's rig, etc which is required for evaluating
/// the ML skin deformer for a specific agent shape, and provides methods for
/// evaluating the blend shape weights for a batch of agents.
class GU_API GU_AgentMLSkinDeformerShapeCache
{
public:
    GU_AgentMLSkinDeformerShapeCache();
    ~GU_AgentMLSkinDeformerShapeCache();
    UT_NON_COPYABLE(GU_AgentMLSkinDeformerShapeCache);

    /// Pre-compute the required info for running the ML skin deformer on the
    /// given shape.
    bool init(
            const GU_AgentShapeLib::Shape &agent_shape,
            const GU_AgentDefinition &agent_defn,
            UT_StringHolder &error_msg);

    /// Run the model for a batch of agents given their world space transforms.
    /// Outputs a flat list of the blend shape weights for each agent, in the
    /// order of the blendshape inputs for this agent shape (e.g. length is
    /// num_agent * numBlendShapes()).
    bool evaluate(
            const UT_Array<UT_Span<const GU_Agent::Matrix4Type>>
                    &agent_world_poses,
            UT_Array<GU_Agent::FloatType> &agent_blend_shape_weights,
            UT_StringHolder &error_msg) const;

    /// Marshal the blendshape weights into the rig's channel order, for a
    /// single agent.
    void setRigChannelValues(
            UT_Span<GU_Agent::FloatType> rig_channel_values,
            const UT_Span<const GU_Agent::FloatType> &blend_shape_weights) const;

    /// Returns the number of blendshape inputs for the shape.
    exint numBlendShapes() const;

private:
    class Impl;

    UT_UniquePtr<Impl> myImpl;
};

/// Utility for baking the ML deformer's blendshape weights back to channel
/// values for a set of agents (which may have mixed agent definitions and/or
/// have multiple shapes using ML deformers).
/// This can be useful for e.g. baking the blendshape weights for export to
/// other file formats.
class GU_API GU_AgentBakeMLSkinDeformer
{
public:
    /// If the agent has one or more shapes using the ML deformer, returns a
    /// unique ID for retrieving its evaluated channel values. Otherwise,
    /// returns -1.
    exint addAgent(const GU_Agent *agent);

    /// Evaluate the blendshape weights for all of the registered agents.
    bool evaluate(UT_StringHolder &error_msg);

    /// Return the rig channel values for the specified agent. This must be
    /// called after evaluate().
    UT_Span<const GU_Agent::FloatType> getChannelValues(
            const GU_Agent *agent,
            exint id) const;

private:
    struct AgentList
    {
        /// List of agents which share the same agent definition and use an ML
        /// deformer.
        UT_Array<UT_IntrusivePtr<const GU_Agent>> myAgents;
        /// Concatenated list of rig channel values for the agent instances.
        UT_Array<GU_Agent::FloatType> myRigChannelValues;
        /// Map from an ML-deforming shape to a list of indices in myAgents
        /// which use the shape.
        UT_Map<GU_AgentShapeLib::ShapePtr, UT_Array<exint>> myShapeBatches;
    };

    /// Map from agent definitions to lists of agents which have ML deformers.
    UT_Map<const GU_AgentDefinition *, AgentList> myAgentLists;
};

#endif