RRMeshData.h

Go to the documentation of this file.

 
#pragma once
 
 
 
// Native
 
#include <string>
 
 
 
// UE
 
#include "Engine/Texture.h"
 
#include "Materials/MaterialInstanceDynamic.h"
 
#include "ProceduralMeshComponent.h"
 
 
 
// Assimp
 
#include "assimp/Importer.hpp"
 
#include "assimp/mesh.h"
 
#include "assimp/scene.h"
 
 
 
// RapyutaSimulationPlugins
 
#include "Core/RRCoreUtils.h"
 
#include "Core/RREntityStructs.h"
 
#include "RapyutaSimulationPlugins.h"
 
 
 
#include "RRMeshData.generated.h"
 
 
 
DECLARE_DELEGATE_TwoParams(FOnMeshCreationDone, bool /* bCreationResult */, UObject* /*MeshBodyComponent*/);
 
 
 
#define RAPYUTA_MESH_VISUAL_DEBUG (1)
 
 
 
struct RAPYUTASIMULATIONPLUGINS_API FRRBoneProperty
 
{
 
public:
 
 
    FString Name;
 
 
 
 
    int32 Index = 0;
 
 
 
 
    int32 ParentIndex = 0;
 
 
 
 
 
    FTransform RelTransform = FTransform::Identity;
 
 
 
 
    FVector MeshScale3D = FVector::OneVector;
 
 
 
 
    FVector MeshSize = FVector::ZeroVector;
 
 
 
 
    float Mass = 0.f;
 
 
 
    FRRRobotLinkProperty ConvertToLinkProperty() const
 
    {
 
        FRRRobotLinkProperty linkProp;
 
        linkProp.Name = Name;
 
        linkProp.LinkIndex = Index;
 
        linkProp.ParentLinkIndex = ParentIndex;
 
        linkProp.Location = RelTransform.GetLocation();
 
        linkProp.Rotation = RelTransform.GetRotation();
 
        linkProp.Inertia.Mass = Mass;
 
        FRREntityGeometryInfo visualInfo;
 
        visualInfo.Size = MeshSize;
 
        visualInfo.WorldScale = MeshScale3D;
 
        FRREntityGeometryInfo collisionInfo = visualInfo;
 
        linkProp.VisualList.Emplace(MoveTemp(visualInfo));
 
        linkProp.CollisionList.Emplace(MoveTemp(collisionInfo));
 
        return linkProp;
 
    }
 
 
 
    FRRRobotJointProperty GetDefaultJointProperty(const FString& InParentLinkName) const
 
    {
 
        FRRRobotJointProperty jointProp;
 
        jointProp.Name = Name;
 
        jointProp.Type = ERRRobotJointType::FIXED;
 
        jointProp.ChildLinkName = Name;
 
        jointProp.ParentLinkName = InParentLinkName;
 
        jointProp.Location = RelTransform.GetLocation();
 
        jointProp.Rotation = RelTransform.GetRotation();
 
        return jointProp;
 
    }
 
 
 
    static void GenerateLinkJointPropListFromBoneProps(const TArray<FRRBoneProperty>& InBonePropList,
 
                                                       FRREntityModelData& OutEntityModelData)
 
    {
 
        auto& linkPropList = OutEntityModelData.LinkPropList;
 
        auto& jointPropList = OutEntityModelData.JointPropList;
 
        for (const auto& boneProp : InBonePropList)
 
        {
 
            linkPropList.Add(boneProp.ConvertToLinkProperty());
 
        }
 
        for (const auto& boneProp : InBonePropList)
 
        {
 
            if (linkPropList.IsValidIndex(boneProp.ParentIndex))
 
            {
 
                jointPropList.Add(boneProp.GetDefaultJointProperty(linkPropList[boneProp.ParentIndex].Name));
 
            }
 
        }
 
    }
 
    void PrintSelf() const;
 
};
 
 
 
struct RAPYUTASIMULATIONPLUGINS_API FRRBoneInfluence
 
{
 
 
 
 
    float Weight = 0.f;
 
 
    int32 VertexIndex = 0;
 
 
    int32 BoneIndex = 0;
 
};
 
 
 
struct RAPYUTASIMULATIONPLUGINS_API FRRBoneVertInfo
 
{
 
 
 
 
    TArray<FVector3f> Positions;
 
 
    TArray<FVector3f> Normals;
 
};
 
 
 
struct RAPYUTASIMULATIONPLUGINS_API FRRMeshNodeData
 
{
 
 
 
 
    TArray<FVector> Vertices;
 
 
    TArray<FColor> VertexColors;
 
 
 
 
    TArray<int32> TriangleIndices;
 
 
 
 
    TArray<FVector> Normals;
 
 
 
 
    TArray<FVector2f> UV2fs;
 
 
 
 
    TArray<FVector2D> UVs;
 
 
 
 
    TArray<FProcMeshTangent> ProcTangents;
 
 
 
 
    TArray<FRRBoneInfluence> BoneInfluences;
 
 
 
 
    uint32 MaterialIndex = 0;
 
 
 
    void Reset(uint64 InNum = 0)
 
    {
 
        Vertices.SetNumZeroed(InNum);
 
        VertexColors.SetNumZeroed(InNum);
 
        Normals.SetNumZeroed(InNum);
 
        UVs.SetNumZeroed(InNum);
 
        UV2fs.SetNumZeroed(InNum);
 
        ProcTangents.SetNumZeroed(InNum);
 
        TriangleIndices.SetNumZeroed(3 * InNum);
 
        BoneInfluences.Reset();
 
    }
 
 
 
    void PrintSelf() const;
 
};
 
 
 
struct RAPYUTASIMULATIONPLUGINS_API FRRMeshNode
 
{
 
 
 
 
    FTransform RelativeTransform = FTransform::Identity;
 
 
 
 
    int NodeParentIndex = 0;
 
 
 
 
    TArray<FRRMeshNodeData> Meshes;
 
};
 
 
 
struct RAPYUTASIMULATIONPLUGINS_API FRRMeshData
 
{
 
private:
 
    static TMap<FString /* MeshUniqueName */, TSharedPtr<FRRMeshData>> MeshDataStore;
 
 
 
public:
 
    static void AddMeshData(const FString& InMeshUniqueName, const TSharedPtr<FRRMeshData>& InMeshData)
 
    {
 
        MeshDataStore.Add(InMeshUniqueName, InMeshData);
 
    }
 
    static TSharedPtr<FRRMeshData> GetMeshData(const FString& InMeshUniqueName)
 
    {
 
        return MeshDataStore.FindRef(InMeshUniqueName);
 
    }
 
    static bool IsMeshDataAvailable(const FString& InMeshUniqueName)
 
    {
 
        return MeshDataStore.Contains(InMeshUniqueName);
 
    }
 
 
 
 
    FString MeshUniqueName;
 
 
 
 
    TSharedPtr<Assimp::Importer> MeshImporter = nullptr;
 
 
 
 
    bool bIsValid = false;
 
    bool IsValid() const
 
    {
 
        return bIsValid;
 
    }
 
 
 
 
    TArray<FRRMeshNode> Nodes;
 
 
 
 
    TArray<UMaterialInstanceDynamic*> MaterialInstances;
 
 
 
    void Reset()
 
    {
 
        Nodes.Reset();
 
        MaterialInstances.Reset();
 
    }
 
 
 
    void PrintSelf() const;
 
 
 
    void TransformBy(const FTransform& InTransform)
 
    {
 
        for (auto& meshNode : Nodes)
 
        {
 
            for (auto& mesh : meshNode.Meshes)
 
            {
 
                for (auto& vertex : mesh.Vertices)
 
                {
 
                    vertex = InTransform.TransformPosition(vertex);
 
                }
 
 
 
                for (auto& normal : mesh.Normals)
 
                {
 
                    normal = InTransform.TransformVectorNoScale(normal);
 
                }
 
 
 
                for (auto& procTangent : mesh.ProcTangents)
 
                {
 
                    procTangent.TangentX = InTransform.TransformVectorNoScale(procTangent.TangentX);
 
                }
 
            }
 
        }
 
    }
 
 
 
    int32 GetVerticesNum() const
 
    {
 
        int32 verticesNum = 0;
 
        for (const auto& meshNode : Nodes)
 
        {
 
            for (const auto& mesh : meshNode.Meshes)
 
            {
 
                verticesNum += mesh.Vertices.Num();
 
            }
 
        }
 
        return verticesNum;
 
    }
 
 
 
    bool HasVertexColors() const
 
    {
 
        for (const auto& meshNode : Nodes)
 
        {
 
            for (const auto& mesh : meshNode.Meshes)
 
            {
 
                if (mesh.VertexColors.Num() > 0)
 
                {
 
                    return true;
 
                }
 
            }
 
        }
 
        return false;
 
    }
 
 
 
    int32 GetIndicesNum() const
 
    {
 
        int32 indicesNum = 0;
 
        for (const auto& meshNode : Nodes)
 
        {
 
            for (const auto& mesh : meshNode.Meshes)
 
            {
 
                indicesNum += mesh.TriangleIndices.Num();
 
            }
 
        }
 
        return indicesNum;
 
    }
 
 
 
    int32 GetUVsNum() const
 
    {
 
        for (const auto& meshNode : Nodes)
 
        {
 
            for (const auto& mesh : meshNode.Meshes)
 
            {
 
                return mesh.UVs.Num();
 
            }
 
        }
 
        return 0;
 
    }
 
};