MeshAdapterTransforms.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
 
#include "FrameTypes.h"
#include "MathUtil.h"
#include "VectorTypes.h"
 
#include "Async/ParallelFor.h"
 
namespace MeshAdapterTransforms
{
    using namespace UE::Geometry;
    using FFrame3d = UE::Geometry::FFrame3d;
 
    template<class TriangleMeshType>
    void Translate(TriangleMeshType& Mesh, const FVector3d& Translation)
    {
        int NumVertices = Mesh.MaxVertexID();
        ParallelFor(NumVertices, [&](int vid) 
        {
            if (Mesh.IsVertex(vid))
            {
                Mesh.SetVertex(vid, Mesh.GetVertex(vid) + Translation);
            }
        });
    }
 
    template<class TriangleMeshType>
    void WorldToFrameCoords(TriangleMeshType& Mesh, const FFrame3d& Frame)
    {
        int NumVertices = Mesh.MaxVertexID();
        ParallelFor(NumVertices, [&](int vid)
        {
            if (Mesh.IsVertex(vid))
            {
                FVector3d Position = Mesh.GetVertex(vid);
                Mesh.SetVertex(vid, Frame.ToFramePoint(Position));
            }
        });
 
        if (Mesh.HasNormals())
        {
            int NumNormals = Mesh.MaxNormalID();
            ParallelFor(NumNormals, [&](int elemid)
            {
                if (Mesh.IsNormal(elemid))
                {
                    FVector3f Normal = Mesh.GetNormal(elemid);
                    Mesh.SetNormal(elemid, (FVector3f)Frame.ToFrameVector((FVector3d)Normal));
                }
            });
        }
    }
 
    template<class TriangleMeshType>
    void FrameCoordsToWorld(TriangleMeshType& Mesh, const FFrame3d& Frame)
    {
        int NumVertices = Mesh.MaxVertexID();
        ParallelFor(NumVertices, [&](int vid)
        {
            if (Mesh.IsVertex(vid))
            {
                FVector3d Position = Mesh.GetVertex(vid);
                Mesh.SetVertex(vid, Frame.FromFramePoint(Position));
            }
        });
 
        if (Mesh.HasNormals())
        {
            int NumNormals = Mesh.MaxNormalID();
            ParallelFor(NumNormals, [&](int elemid)
            {
                if (Mesh.IsNormal(elemid))
                {
                    FVector3f Normal = Mesh.GetNormal(elemid);
                    Mesh.SetNormal(elemid, (FVector3f)Frame.FromFrameVector((FVector3d)Normal));
                }
            });
        }
    }
 
 
    template<class TriangleMeshType>
    void ApplyTransform(TriangleMeshType& Mesh, const FTransformSRT3d& Transform)
    {
        int NumVertices = Mesh.MaxVertexID();
        ParallelFor(NumVertices, [&](int vid)
        {
            if (Mesh.IsVertex(vid))
            {
                FVector3d Position = Mesh.GetVertex(vid);
                Position = Transform.TransformPosition(Position);
                Mesh.SetVertex(vid, Position);
            }
        });
 
        if (Mesh.HasNormals())
        {
            int NumNormals = Mesh.MaxNormalID();
            ParallelFor(NumNormals, [&](int elemid)
            {
                if (Mesh.IsNormal(elemid))
                {
                    FVector3f Normal = Mesh.GetNormal(elemid);
                    Mesh.SetNormal(elemid, (FVector3f)Transform.TransformNormal((FVector3d)Normal));
                }
            });
        }
    }
 
 
    template<class TriangleMeshType>
    void ApplyTransformInverse(TriangleMeshType& Mesh, const FTransformSRT3d& Transform)
    {
        int NumVertices = Mesh.MaxVertexID();
        ParallelFor(NumVertices, [&](int vid)
        {
            if (Mesh.IsVertex(vid)) 
            {
                FVector3d Position = Mesh.GetVertex(vid);
                Position = Transform.InverseTransformPosition(Position);
                Mesh.SetVertex(vid, Position);
            }
        });
 
        if (Mesh.HasNormals())
        {
            int NumNormals = Mesh.MaxNormalID();
            ParallelFor(NumNormals, [&](int elemid)
            {
                if (Mesh.IsNormal(elemid))
                {
                    FVector3f Normal = Mesh.GetNormal(elemid);
                    Mesh.SetNormal(elemid, (FVector3f)Transform.InverseTransformNormal((FVector3d)Normal));
                }
            });
        }
    }
 
 
    template<class TriangleMeshType>
    void ApplyTransform(TriangleMeshType& Mesh,
        TFunctionRef<FVector3d(const FVector3d&)> PositionTransform,
        TFunctionRef<FVector3f(const FVector3f&)> NormalTransform)
    {
        int NumVertices = Mesh.MaxVertexID();
        ParallelFor(NumVertices, [&](int vid)
        {
            if (Mesh.IsVertex(vid))
            {
                FVector3d Position = Mesh.GetVertex(vid);
                Position = PositionTransform(Position);
                Mesh.SetVertex(vid, Position);
            }
        });
 
        if (Mesh.HasNormals())
        {
            int NumNormals = Mesh.MaxNormalID();
            ParallelFor(NumNormals, [&](int elemid)
            {
                if (Mesh.IsNormal(elemid))
                {
                    FVector3f Normal = Mesh.GetNormal(elemid);
                    Normal = NormalTransform(Normal);
                    Mesh.SetNormal(elemid, UE::Geometry::Normalized(Normal));
                }
            });
        }
    }
 
};