GLTF_Refiner.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018
 *      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.
 */

#ifndef __GLTF_REFINER_h__
#define __GLTF_REFINER_h__

#include "GLTFZ_API.h"

#include <GA/GA_Types.h>
#include <GLTF/GLTF_Types.h>
#include <GLTFZ/GLTF_ExportRoot.h>
#include <GT/GT_AttributeList.h>
#include <GT/GT_DANumeric.h>
#include <GT/GT_Refine.h>
#include <GT/GT_Types.h>
#include <UT/UT_IntrusivePtr.h>
#include <UT/UT_Options.h>
#include <UT/UT_StringMap.h>

#include <functional>

class GT_PrimPointMesh;
class GT_PrimPolygonMesh;
class GT_PrimInstance;
class GU_Detail;
class GT_GEOPrimPacked;

namespace GLTF_NAMESPACE
{

class GLTF_Refiner;
typedef UT_IntrusivePtr<GLTF_Refiner> GLTF_RefinerHandle;

class GLTFZ_API GLTF_Refiner : public GT_Refine,
                         public UT_IntrusiveRefCounter<GLTF_Refiner>
{
private:

    const int32 NOT_IN_SUBMESH = -1;

    struct CachedData
    {
        // Each element of these arrays represents a prim in the mesh
        UT_Array<UT_IntArray> material_faces_map;
        UT_Array<GT_DataArrayHandle> prim_indirect_mapping;
        // Maps a submesh index to an attribute map
        UT_Map<exint, UT_StringMap<GT_DataArrayHandle>> point_attributes;

        UT_Array<GT_DataArrayHandle> main_id_to_submesh_id_map;

        GT_DataArrayHandle split_verts;
    };

    struct InstanceData
    {
        UT_StringHolder name;
        UT_StringHolder path;
        GLTF_Handle node = GLTF_INVALID_IDX;
        UT_Array<UT_Matrix4D> xforms;
        GLTF_RefinerHandle refiner;
    };

public:
    enum class MeshNameSource
    {
        NONE,
        NODE_NAME,
        ATTRIBUTE
    };

    struct RefineOptions
    {
        bool output_custom_attribs = false;
        bool exporting_skin = false;
        // Gets a handle to the associated gltf node
        std::function<exint(exint)> boneCapture_index_to_joint = {};
        bool blendshape = false;

        MeshNameSource mesh_name_source;
        UT_StringHolder mesh_name_val;
    };

   struct BlendShapeInfo
    {
        UT_StringHolder channel;
        UT_StringHolder name; 
        GT_AttributeListHandle base_shape = nullptr;
        CachedData* base_shape_cached_data = nullptr;
        UT_ArrayMap<int, UT_Array<int>>* split_points_map = nullptr;
    };

    GLTF_Refiner(GLTF_ExportRoot &root, GLTF_Node *node,
        const UT_StringHolder &obj_material,
        std::function<GLTF_Handle(UT_StringHolder, UT_Options&)> create_material,
        RefineOptions options,
        GLTF_BaseErrorManager* error_manager);
    ~GLTF_Refiner() override = default;

    void addPrimitive(const GT_PrimitiveHandle &prim) override;

    // GLTF buffer allocation is currently unprotected
    bool allowThreading() const override { return false; }

    ///
    /// A convenience function.  Refines the detail, and adds meshes 
    /// (or potentially submeshes if instancing is used) to the GLTF_Node
    /// that is passed in.
    ///
    static GLTF_RefinerHandle refine(
        const GU_Detail *src,
        GLTF_ExportRoot &root,
        GLTF_Node &node,
        const UT_StringHolder &obj_material,
        std::function<GLTF_Handle(UT_StringHolder, UT_Options&)> create_material,
        RefineOptions options,
        GLTF_BaseErrorManager* error_manager);

    // Use cached data to refine different frames of the same geometry
    void setAddingSubsequentFrames(bool use);

    void setNode(GLTF_Node* node);

    void animateInstanceXforms(
            std::function<void(GLTF_Handle, const UT_Array<UT_Matrix4D> &)>
                    func);

    void setBlendShapeInfo(BlendShapeInfo info);

private:
    void processPrimPolygon(GT_PrimPolygonMesh *prim, UT_Matrix4D trans,
                            GLTF_Mesh &mesh);

    bool processInstance(const GT_PrimInstance *instance);
    void processInstanceFrame(const GT_PrimInstance *instance);
    void processBlendShape(const GT_PrimInstance* shape);

    void addBlendShape(const GT_AttributeListHandle& p_list);

    GLTF_Handle appendMeshIfNotEmpty(GLTF_Mesh &mesh,
                                     const GT_Primitive* prim);

    void
    addMesh(const GT_PrimPolygonMesh &prim, UT_Matrix4D trans, GLTF_Mesh &mesh);

    // Creates a GLTF_Primitive based on the given attributes and
    // indices then returns a reference to it.
    GLTF_Primitive &addPoints(
            const GT_AttributeListHandle &attributes,
            const GT_DataArrayHandle &indices,
            GLTF_Mesh &mesh,
            exint submesh_idx);

    void addMorphTarget(
            const GT_AttributeListHandle &attributes,
            GLTF_Mesh &mesh,
            exint prim_index);

    // Translates a Houdini component type to the 'closest' GLTF
    // component type
    GLTF_ComponentType GetComponentTypeFromStorage(GT_Storage storage);

    struct Attrib_CopyResult
    {
        uint32 size;
        uint32 offset;
        UT_Array<fpreal64> elem_min;
        UT_Array<fpreal64> elem_max;
        uint32 entries;
    };

    template <typename T, typename FUNC_CAST>
    Attrib_CopyResult
    CopyAttribData(uint32 bid, const T *arr, GT_Size entries,
                   GT_Size old_tuple_size, GT_Size new_tuple_size,
                   std::function<void(FUNC_CAST *)> func, uint32 stride);

    //
    // Allocates data from the GLTF buffer 'bid' and moves attribute data
    // to handle, converting type if needed.
    // If old_tuple_size > new_tuple_size, then the size of the tuple will
    // be truncated (this is mainly used for UVs).
    //
    template <typename T = void>
    uint32 AddAttrib(const GT_DataArrayHandle &handle,
                     GLTF_ComponentType target_type, GT_Size new_tuple_size,
                     uint32 bid, GLTF_BufferViewTarget buffer_type,
                     std::function<void(T *)> func = {}, uint32 stride = 1);

    bool ExportAttribute(
            const UT_StringRef &attrib_name,
            const GT_DataArrayHandle &attrib_data,
            UT_StringMap<uint32> &attribute_map);

    uint32 addBlendShapeAttribute(
        const GT_AttributeListHandle& blend_shape_attribs,
        const UT_StringHolder& attrib_name,
        GLTF_Primitive& prim,
        exint submesh_idx);

    bool addBoneCaptureAttribs(
            const GT_DataArrayHandle &attrib_data,
            UT_StringMap<uint32> &attribute_map);

    static exint getNumSubMeshes(UT_Array<UT_IntArray>& material_faces_map); 

    GLTF_ExportRoot &myRoot;
    GLTF_Node *myNode;
    const UT_StringHolder &myObjectMaterial;
    std::function<GLTF_Handle(UT_StringHolder, UT_Options &)> myCreateMaterial;
    const RefineOptions myOptions;

    CachedData myCachedData;
    UT_Array<InstanceData> myInstances;
    bool myAddingSubsequentFrames;

    GLTF_BaseErrorManager* myErrorManager;

    GT_AttributeListHandle myPolygonMesh;
    CachedData* myPolygonMeshCachedData;
    BlendShapeInfo myBlendShapeInfo;
    UT_ArrayMap<int, UT_Array<int>> mySplitPointsMap;
};

class GLTFZ_API GLTF_PointSplit
{
public:
    static bool
    Split(const GT_PrimPolygonMesh &polymesh, fpreal64 tol,
          GT_AttributeListHandle &new_points, GT_DataArrayHandle &new_vertices,
          UT_ArrayMap<int, UT_Array<int>>& split_points_map,
          GLTF_BaseErrorManager* error_manager);

private:
    GLTF_PointSplit(const GT_PrimPolygonMesh &prim, fpreal64 tol,
        GLTF_BaseErrorManager* error_manager);

    // Refines detail and prim attributes down to vertex attributes
    // (which will later be refined into point attributes)
    GT_AttributeListHandle refineDetailPrims();

    // Returns true if the points can be merged
    template <typename T>
    inline bool compareAttribs(GT_Offset pt_1, GT_Offset pt_2, T *attr_arr,
                        GT_Size tuple_size) const
    {
        for (exint idx = 0; idx < tuple_size; idx++)
        {
            GT_Offset of1 = pt_1 * tuple_size + idx;
            GT_Offset of2 = pt_2 * tuple_size + idx;
            if (SYSabs(attr_arr[of1] - attr_arr[of2]) > myTol)
            {
                return true;
            }
        }

        return false;
    }

    template <typename T>
    inline bool compareArrayAttribs(GT_Offset pt_1, GT_Offset pt_2,
        const UT_Array<T>& vals, const UT_Array<int>& arr_sizes,
        const UT_Array<GT_Offset>& offset_cache) const
    {
        int arr_size1 = arr_sizes[pt_1];
        int arr_size2 = arr_sizes[pt_2];

        if (arr_size1 != arr_size2)
        {
            return true;
        }

        GT_Offset off1 = offset_cache[pt_1];
        GT_Offset off2 = offset_cache[pt_2];

        for (exint arr_idx = 0; arr_idx < arr_size1; arr_idx++)
        {
            if (SYSabs(vals[off1+arr_idx] - vals[off2+arr_idx]) > myTol)
            {
                return true;
            }
        }

        return false;
    }

    template <typename T>
    GT_DataArrayHandle
    splitAttribute(GT_Int32Array *new_verts,
                   UT_Array<UT_Array<GT_Offset>> &vertexes_using_point,
                   GT_Int32Array *new_pts_indirect, T *attr_arr,
                   GT_Size tuple_size,
                   UT_ArrayMap<int, UT_Array<int>>& split_points_map);

    template <typename T>
    GT_DataArrayHandle
    splitAttribute(GT_Int32Array* new_verts,
                   UT_Array<UT_Array<GT_Offset>>& vertexes_using_point,
                   GT_Int32Array* new_pts_indirect,
                   const UT_Array<T>& vals,
                   const UT_Array<int>& arr_sizes,
                   const UT_Array<GT_Offset>& offset_cache,
                   UT_ArrayMap<int, UT_Array<int>>& split_points_map);

    bool
    splitAttrib(GT_AttributeListHandle &new_points, GT_DataArrayHandle &new_vertice,
          const GT_AttributeListHandle &vertex_attribs, exint idx,
          UT_ArrayMap<int, UT_Array<int>>& split_points_map);

    const GT_PrimPolygonMesh &myPrim;
    const fpreal myTol;
    UT_ArrayMap<int, int> mySourcePointMap;
    GLTF_BaseErrorManager* myErrorManager;
};

}

#endif