CGNICO/UnrealEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c11d382a6f0acddb0bc1e95ab9bc5f8fc3570b55
UnrealEngine/Engine/Plugins/Mutable/Source/MutableRuntime/Private/MuR/OpImageProject.cpp
Jeffreytsai1004 c11d382a6f ue5-main
2025-05-18 13:04:45 +08:00

3127 lines
123 KiB
C++
Raw Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
#include "MuR/OpImageProject.h"
#include "MuR/ConvertData.h"
#include "MuR/Image.h"
#include "MuR/ImagePrivate.h"
#include "MuR/Layout.h"
#include "MuR/MeshBufferSet.h"
#include "MuR/MeshPrivate.h"
#include "MuR/MutableMath.h"
#include "MuR/MutableTrace.h"
#include "MuR/OpMeshClipWithMesh.h"
#include "MuR/Parameters.h"
#include "MuR/ParametersPrivate.h"
#include "MuR/Ptr.h"
#include "MuR/Raster.h"
#include "Async/ParallelFor.h"
#include "Containers/Array.h"
#include "Intersection/IntrRay3Triangle3.h"
#include "Math/IntPoint.h"
#include "Math/UnrealMathSSE.h"
#include "Misc/AssertionMacros.h"
#include "Math/UnrealMathUtility.h"
#include "Spatial/PointHashGrid3.h"
#include "MuR/Image.h"
#include "MuR/Mesh.h"
namespace mu
{
//-------------------------------------------------------------------------------------------------
//! This format is the one we assumee the meshes optimised for planar and cylindrical projection
//! will have.
//! See CreateMeshOptimisedForProjection
struct FOptimizedVertex
{
FVector2f Uv;
FVector3f Position;
FVector3f Normal;
};
static_assert(sizeof(FOptimizedVertex)==32, "UNEXPECTED_STRUCT_SIZE" );
namespace Private
{
struct FImageRasterInvokeArgs
{
const FMesh* MeshPtr;
FImage* ImagePtr;
const FImage* SourcePtr;
const FImage* MaskPtr;
bool bIsRGBFadingEnabled;
bool bIsAlphaFadingEnabled;
ESamplingMethod SamplingMethod;
float FadeStart;
float FadeEnd;
float ProjectionAngle;
float MipInterpolationFactor;
int32 Layout;
uint64 BlockId;
UE::Math::TIntVector2<uint16> CropMin;
UE::Math::TIntVector2<uint16> UncroppedSize;
FScratchImageProject* Scratch;
};
enum class EPixelProcessorFeatures
{
None = 0,
WithMask = 1 << 1,
SamplingPoint = 1 << 2,
SamplingLinear = 1 << 3,
ProjectionPlanar = 1 << 4,
ProjectionCylindrical = 1 << 5,
ProjectionWrap = 1 << 6,
FormatRGBA = 1 << 7,
FormatRGB = 1 << 8,
FormatL = 1 << 9,
VectorizedImpl = 1 << 10
};
ENUM_CLASS_FLAGS(EPixelProcessorFeatures);
constexpr bool CheckExactlyOneFormatFlag(EPixelProcessorFeatures Features)
{
return
static_cast<int32>(EnumHasAnyFlags(Features, EPixelProcessorFeatures::FormatL)) +
static_cast<int32>(EnumHasAnyFlags(Features, EPixelProcessorFeatures::FormatRGB)) +
static_cast<int32>(EnumHasAnyFlags(Features, EPixelProcessorFeatures::FormatRGBA)) == 1;
}
constexpr bool CheckExactlyOneSamplingFlag(EPixelProcessorFeatures Features)
{
return
static_cast<int32>(EnumHasAnyFlags(Features, EPixelProcessorFeatures::SamplingPoint)) +
static_cast<int32>(EnumHasAnyFlags(Features, EPixelProcessorFeatures::SamplingLinear)) == 1;
}
constexpr bool CheckExactlyOneProjectionFlag(EPixelProcessorFeatures Features)
{
return
static_cast<int32>(EnumHasAnyFlags(Features, EPixelProcessorFeatures::ProjectionCylindrical)) +
static_cast<int32>(EnumHasAnyFlags(Features, EPixelProcessorFeatures::ProjectionPlanar)) +
static_cast<int32>(EnumHasAnyFlags(Features, EPixelProcessorFeatures::ProjectionWrap)) == 1;
}
constexpr int32 GetFormatNumChannels(EPixelProcessorFeatures Features)
{
if (EnumHasAnyFlags(Features, EPixelProcessorFeatures::FormatL))
{
return 1;
}
else if (EnumHasAnyFlags(Features, EPixelProcessorFeatures::FormatRGB))
{
return 3;
}
else if (EnumHasAnyFlags(Features, EPixelProcessorFeatures::FormatRGBA))
{
return 4;
}
return -1;
}
// The processor constant data fits into a 64 bytes cache line, align to it so potentially have less cache
// misses.
struct alignas(64) FProjectedPixelProcessorContext
{
const uint8* TargetData = nullptr;
const uint8* Source0Data = nullptr;
uint16 Source0SizeX = 0;
uint16 Source0SizeY = 0;
uint16 Source1SizeX = 0;
uint16 Source1SizeY = 0;
const uint8* Source1Data = nullptr;
const uint8* MaskData = nullptr;
//! Cosine of the fading angle range
float FadeEndCos = 0.0f;
// precomputation of 255 / (FadeStartCos - FadeEndCos)
float OneOverFadeRangeTimes255 = 0.0f;
// Only used for cylindrical projections.
float OneOverProjectionAngle = 0.0f;
// Only used with linear sampling.
float MipInterpolationFactor = 0.0f;
// Those are the seed for a mask 0xFFFFFFFF (-1) mask for enabled and 0 otherwise.
// so, the expected value here is -1 for enabled and 0 for disabled.
int32 RGBFadingEnabledMask = 0;
int32 AlphaFadingEnabledMask = 0;
};
static_assert(sizeof(FProjectedPixelProcessorContext) <= 64);
template<EPixelProcessorFeatures Features>
class TProjectedPixelProcessor
{
static_assert(CheckExactlyOneFormatFlag(Features));
static_assert(CheckExactlyOneSamplingFlag(Features));
static_assert(CheckExactlyOneProjectionFlag(Features));
static constexpr int32 PIXEL_SIZE = GetFormatNumChannels(Features);
static_assert(PIXEL_SIZE != -1 && PIXEL_SIZE > 0);
public:
static FProjectedPixelProcessorContext MakeContext(
const FImage* Source,
const uint8* InTargetData,
const uint8* InMaskData,
bool bInIsRGBFadingEnabled, bool bInIsAlphaFadingEnabled,
float FadeStart, float FadeEnd, float InProjectionAngle, float InMipInterpolationFactor)
{
FProjectedPixelProcessorContext Context;
Context.Source0SizeX = static_cast<uint16>(Source->GetSizeX());
Context.Source0SizeY = static_cast<uint16>(Source->GetSizeY());
Context.Source0Data = (Context.Source0SizeX > 0 && Context.Source0SizeY > 0) ? Source->GetLODData(0) : nullptr;
if constexpr (EnumHasAnyFlags(Features, EPixelProcessorFeatures::SamplingLinear))
{
// If we don't have the next mip, use the first mip as a fallback.
const bool bHasNextMip = Source->GetLODCount() >= 2;
Context.Source1Data = bHasNextMip ? Source->GetMipData(1) : Context.Source0Data;
FIntVector2 Source1Size = Source->CalculateMipSize(1);
Context.Source1SizeX = bHasNextMip ? static_cast<uint16>(Source1Size.X) : Context.Source0SizeX;
Context.Source1SizeY = bHasNextMip ? static_cast<uint16>(Source1Size.Y) : Context.Source0SizeY;
// Invalidate SourceData if either of the two is not valid.
if (!(Context.Source0Data && Context.Source1Data))
{
Context.Source0Data = nullptr;
Context.Source1Data = nullptr;
}
}
Context.MipInterpolationFactor = InMipInterpolationFactor;
Context.RGBFadingEnabledMask = bInIsRGBFadingEnabled ? -1 : 0;
Context.AlphaFadingEnabledMask = bInIsAlphaFadingEnabled ? -1 : 0;
if constexpr (EnumHasAnyFlags(Features, EPixelProcessorFeatures::ProjectionPlanar))
{
const float FadeStartCos = FMath::Cos(FadeStart);
Context.FadeEndCos = FMath::Cos(FadeEnd);
const float FadeCosRangeSafeDiv =
FMath::IsNearlyZero(FadeStartCos - Context.FadeEndCos, UE_KINDA_SMALL_NUMBER)
? UE_KINDA_SMALL_NUMBER
: FadeStartCos - Context.FadeEndCos;
Context.OneOverFadeRangeTimes255 = 255.0f / FadeCosRangeSafeDiv;
}
else
{
Context.FadeEndCos = 0.0f;
Context.OneOverFadeRangeTimes255 = 255.0f;
}
Context.OneOverProjectionAngle = FMath::IsNearlyZero(InProjectionAngle)
? 1.0f / UE_KINDA_SMALL_NUMBER
: 1.0f / InProjectionAngle;
Context.TargetData = InTargetData;
Context.MaskData = InMaskData;
check(GetImageFormatData(Source->GetFormat()).BytesPerBlock == PIXEL_SIZE);
return Context;
}
static void ProcessPixel(const FProjectedPixelProcessorContext& Context, uint8* BufferPos, float Varying[4])
{
if constexpr (EnumHasAnyFlags(Features, EPixelProcessorFeatures::VectorizedImpl))
{
ProcessPixelVectorImpl(Context, BufferPos, Varying);
}
else
{
ProcessPixelImpl(Context, BufferPos, Varying);
}
}
private:
static void ProcessPixelVectorImpl(const FProjectedPixelProcessorContext& Context, uint8* BufferPos, float Varying[4])
{
if (!Context.Source0Data)
{
return;
}
const bool bDepthClamp = Invoke([&]() -> bool
{
if constexpr (EnumHasAnyFlags(Features, EPixelProcessorFeatures::ProjectionCylindrical))
{
const FVector2f CylinderPolarCoords(Varying[1], Varying[2]);
return FVector2f::DotProduct(CylinderPolarCoords, CylinderPolarCoords) > 1.0f;
}
else
{
return static_cast<bool>((Varying[2] < 0.0f) | (Varying[2] > 1.0f));
}
});
float Factor = static_cast<float>(!bDepthClamp) * 255.0f;
float MaskFactor = 255.0f;
if constexpr (EnumHasAnyFlags(Features, EPixelProcessorFeatures::ProjectionPlanar))
{
const float AngleCos = Varying[3];
Factor = FMath::Min(Factor, (FMath::Clamp((AngleCos - Context.FadeEndCos) * Context.OneOverFadeRangeTimes255, 0.0f, 255.0f)));
MaskFactor = AngleCos > Context.FadeEndCos ? 255.0f : 0.0f;
}
if constexpr (EnumHasAnyFlags(Features, EPixelProcessorFeatures::WithMask))
{
// Only read from memory if needed.
if (Factor > UE_SMALL_NUMBER)
{
MaskFactor = ((MaskFactor > 0.0f) && Context.MaskData)
? static_cast<float>(Context.MaskData[(BufferPos - Context.TargetData) / PIXEL_SIZE]) //-V609
: MaskFactor;
Factor = (Factor * MaskFactor) * (1.0f/255.0f);
}
}
if (Factor > UE_SMALL_NUMBER)
{
const FVector2f Uv = Invoke([&]()
{
if constexpr (EnumHasAnyFlags(Features, EPixelProcessorFeatures::ProjectionCylindrical))
{
return FVector2f{ 0.5f + FMath::Atan2(Varying[2], -Varying[1]) * Context.OneOverProjectionAngle, Varying[0] };
}
else
{
return FVector2f{ Varying[0], Varying[1] };
}
});
if ((Uv.X >= 0.0f) & (Uv.X < 1.0f) & (Uv.Y >= 0.0f) & (Uv.Y < 1.0f))
{
using namespace GlobalVectorConstants;
auto LoadPixel = [](const uint8* Ptr) -> VectorRegister4Float
{
constexpr VectorRegister4Float OneOver255 =
MakeVectorRegisterFloatConstant(1.0f / 255.0f, 1.0f / 255.0f, 1.0f / 255.0f, 1.0f / 255.0f);
if constexpr (PIXEL_SIZE == 4)
{
const uint32 PackedData = *reinterpret_cast<const uint32*>(Ptr);
return VectorMultiply(MakeVectorRegister(
static_cast<float>((PackedData >> (8 * 0)) & 0xFF),
static_cast<float>((PackedData >> (8 * 1)) & 0xFF),
static_cast<float>((PackedData >> (8 * 2)) & 0xFF),
static_cast<float>((PackedData >> (8 * 3)) & 0xFF)), OneOver255);
}
else
{
alignas(VectorRegister4Float) float PixelData[4];
for (int32 C = 0; C < PIXEL_SIZE; ++C)
{
PixelData[C] = static_cast<float>(Ptr[C]);
}
return VectorMultiply(VectorLoadAligned(&(PixelData[0])), OneOver255);
}
};
VectorRegister4Float Result;
if constexpr (EnumHasAnyFlags(Features, EPixelProcessorFeatures::SamplingLinear))
{
const VectorRegister4Int SizeI =
MakeVectorRegisterInt(Context.Source0SizeX, Context.Source0SizeY, Context.Source1SizeX, Context.Source1SizeY);
const VectorRegister4Float SizeF = VectorIntToFloat(SizeI);
const VectorRegister4Float CoordsF = VectorMin(VectorMax(
VectorMultiplyAdd(MakeVectorRegister(Uv.X, Uv.Y, Uv.X, Uv.Y), SizeF, FloatMinusOneHalf),
FloatZero),
VectorSubtract(SizeF, FloatOne));
const VectorRegister4Float Frac = VectorSubtract(CoordsF, VectorFloor(CoordsF));
const VectorRegister4Int CoordsI = VectorFloatToInt(CoordsF);
const VectorRegister4Int CoordsIPlusOne = VectorIntMin(
VectorIntAdd(CoordsI, IntOne), VectorIntSubtract(SizeI, IntOne));
alignas(VectorRegister4Int) int32 CoordsIData[4];
VectorIntStoreAligned(CoordsI, CoordsIData);
alignas(VectorRegister4Int) int32 CoordsIPlusOneData[4];
VectorIntStoreAligned(CoordsIPlusOne, CoordsIPlusOneData);
uint8 const* const Pixel000Ptr = Context.Source0Data + (CoordsIData[1] * Context.Source0SizeX + CoordsIData[0]) * PIXEL_SIZE;
uint8 const* const Pixel010Ptr = Context.Source0Data + (CoordsIData[1] * Context.Source0SizeX + CoordsIPlusOneData[0]) * PIXEL_SIZE;
uint8 const* const Pixel001Ptr = Context.Source0Data + (CoordsIPlusOneData[1] * Context.Source0SizeX + CoordsIData[0]) * PIXEL_SIZE;
uint8 const* const Pixel011Ptr = Context.Source0Data + (CoordsIPlusOneData[1] * Context.Source0SizeX + CoordsIPlusOneData[0]) * PIXEL_SIZE;
uint8 const* const Pixel100Ptr = Context.Source1Data + (CoordsIData[3] * Context.Source1SizeX + CoordsIData[2]) * PIXEL_SIZE;
uint8 const* const Pixel110Ptr = Context.Source1Data + (CoordsIData[3] * Context.Source1SizeX + CoordsIPlusOneData[2]) * PIXEL_SIZE;
uint8 const* const Pixel101Ptr = Context.Source1Data + (CoordsIPlusOneData[3] * Context.Source1SizeX + CoordsIData[2]) * PIXEL_SIZE;
uint8 const* const Pixel111Ptr = Context.Source1Data + (CoordsIPlusOneData[3] * Context.Source1SizeX + CoordsIPlusOneData[2]) * PIXEL_SIZE;
const VectorRegister4Float Pixel000 = LoadPixel(Pixel000Ptr);
const VectorRegister4Float Pixel010 = LoadPixel(Pixel010Ptr);
const VectorRegister4Float Pixel001 = LoadPixel(Pixel001Ptr);
const VectorRegister4Float Pixel011 = LoadPixel(Pixel011Ptr);
const VectorRegister4Float Pixel100 = LoadPixel(Pixel100Ptr);
const VectorRegister4Float Pixel110 = LoadPixel(Pixel110Ptr);
const VectorRegister4Float Pixel101 = LoadPixel(Pixel101Ptr);
const VectorRegister4Float Pixel111 = LoadPixel(Pixel111Ptr);
const VectorRegister4Float Frac0X = VectorReplicate(Frac, 0);
const VectorRegister4Float Frac0Y = VectorReplicate(Frac, 1);
// Bilerp image 0
VectorRegister4Float Sample0 = VectorMultiplyAdd(Frac0X, VectorSubtract(Pixel010, Pixel000), Pixel000);
Sample0 = VectorMultiplyAdd(
Frac0Y,
VectorSubtract(
VectorMultiplyAdd(Frac0X, VectorSubtract(Pixel011, Pixel001), Pixel001),
Sample0),
Sample0);
const VectorRegister4Float Frac1X = VectorReplicate(Frac, 2);
const VectorRegister4Float Frac1Y = VectorReplicate(Frac, 3);
// Bilerp image 1
VectorRegister4Float Sample1 = VectorMultiplyAdd(Frac1X, VectorSubtract(Pixel110, Pixel100), Pixel100);
Sample1 = VectorMultiplyAdd(
Frac1Y,
VectorSubtract(
VectorMultiplyAdd(Frac1X, VectorSubtract(Pixel111, Pixel101), Pixel101),
Sample1),
Sample1);
Result = VectorMultiplyAdd(VectorSetFloat1(Context.MipInterpolationFactor), VectorSubtract(Sample1, Sample0), Sample0);
}
else if (EnumHasAnyFlags(Features, EPixelProcessorFeatures::SamplingPoint))
{
const int32 CoordX = FMath::FloorToInt32(Context.Source0SizeX * Uv.X);
const int32 CoordY = FMath::FloorToInt32(Context.Source0SizeY * Uv.Y);
Result = LoadPixel(Context.Source0Data + (CoordY*Context.Source0SizeX + CoordX) * PIXEL_SIZE);
}
Result = VectorMultiply(
Result,
// Fadding factor
VectorSelect(
// The selction mask needs to be 0xFFFFFFFF if enabled 0 otherwise. FadingEnabledValue will be -1
// if enabled and 0 otherwise.
VectorCastIntToFloat(MakeVectorRegisterInt(
static_cast<int32>(Context.RGBFadingEnabledMask),
static_cast<int32>(Context.RGBFadingEnabledMask),
static_cast<int32>(Context.RGBFadingEnabledMask),
static_cast<int32>(Context.AlphaFadingEnabledMask))),
VectorSetFloat1(Factor),
VectorSetFloat1(MaskFactor)));
if constexpr (PIXEL_SIZE == 4)
{
VectorStoreByte4(Result, BufferPos);
VectorResetFloatRegisters();
}
else
{
const AlignedFloat4 ResultData(VectorMin(VectorMax(Result, FloatZero), Float255));
for (int32 C = 0; C < PIXEL_SIZE; ++C)
{
BufferPos[C] = static_cast<uint8>(ResultData[C]);
}
}
}
}
}
static void ProcessPixelImpl(const FProjectedPixelProcessorContext& Context, uint8* BufferPos, float Varying[4])
{
if (!Context.Source0Data)
{
return;
}
const bool bDepthClamp = Invoke([&]() -> bool
{
if constexpr (EnumHasAnyFlags(Features, EPixelProcessorFeatures::ProjectionCylindrical))
{
const FVector2f CylinderPolarCoords(Varying[1], Varying[2]);
return FVector2f::DotProduct(CylinderPolarCoords, CylinderPolarCoords) > 1.0f;
}
else
{
return static_cast<bool>((Varying[2] < 0.0f) | (Varying[2] > 1.0f));
}
});
uint16 Factor = static_cast<uint16>(!bDepthClamp) * 255;
uint16 MaskFactor = 255;
if constexpr (EnumHasAnyFlags(Features, EPixelProcessorFeatures::ProjectionPlanar))
{
const float AngleCos = Varying[3];
Factor = FMath::Min(Factor,
static_cast<uint16>(FMath::Clamp((AngleCos - Context.FadeEndCos) * Context.OneOverFadeRangeTimes255, 0.0f, 255.0f)));
MaskFactor = AngleCos > Context.FadeEndCos ? 255 : 0;
}
if constexpr (EnumHasAnyFlags(Features, EPixelProcessorFeatures::WithMask))
{
// Only read from memory if needed.
if (Factor > 0)
{
MaskFactor = ((MaskFactor > 0) && Context.MaskData)
? Context.MaskData[(BufferPos - Context.TargetData) / PIXEL_SIZE] //-V609
: MaskFactor;
Factor = (Factor * MaskFactor) / 255;
}
}
if (Factor > 0)
{
const FVector2f Uv = Invoke([&]()
{
if constexpr (EnumHasAnyFlags(Features, EPixelProcessorFeatures::ProjectionCylindrical))
{
return FVector2f{ 0.5f + FMath::Atan2(Varying[2], -Varying[1])*Context.OneOverProjectionAngle, Varying[0] };
}
else
{
return FVector2f{ Varying[0], Varying[1] };
}
});
const FVector2f Source0SizeF = FVector2f(Context.Source0SizeX, Context.Source0SizeY);
const FVector2f Source1SizeF = FVector2f(Context.Source1SizeX, Context.Source1SizeY);
if ((Uv.X >= 0.0f) & (Uv.X < 1.0f) & (Uv.Y >= 0.0f) & (Uv.Y < 1.0f))
{
using FUInt16Vector2 = UE::Math::TIntVector2<uint16>;
struct FPixelData
{
alignas(8) uint16 Data[PIXEL_SIZE];
};
auto LoadPixel = [](const uint8* Ptr) -> FPixelData
{
FPixelData Result;
if constexpr (PIXEL_SIZE == 4)
{
const uint32 PackedData = *reinterpret_cast<const uint32*>(Ptr);
Result.Data[0] = static_cast<uint16>((PackedData >> (8 * 0)) & 0xFF);
Result.Data[1] = static_cast<uint16>((PackedData >> (8 * 1)) & 0xFF);
Result.Data[2] = static_cast<uint16>((PackedData >> (8 * 2)) & 0xFF);
Result.Data[3] = static_cast<uint16>((PackedData >> (8 * 3)) & 0xFF);
}
else
{
for (int32 C = 0; C < PIXEL_SIZE; ++C)
{
Result.Data[C] = static_cast<uint16>(Ptr[C]);
}
}
return Result;
};
FPixelData Result;
FMemory::Memzero(Result);
if constexpr (EnumHasAnyFlags(Features, EPixelProcessorFeatures::SamplingLinear))
{
auto SampleImageBilinear = [&](FVector2f Uv, FUInt16Vector2 Size, const uint8* DataPtr)
{
const FVector2f SizeF(Size.X, Size.Y);
const FVector2f CoordsF = FVector2f(
FMath::Clamp(Uv.X * SizeF.X - 0.5f, 0.0f, SizeF.X - 1.0f),
FMath::Clamp(Uv.Y * SizeF.Y - 0.5f, 0.0f, SizeF.Y - 1.0f));
const FUInt16Vector2 Frac = FUInt16Vector2(
static_cast<uint16>(FMath::Frac(CoordsF.X) * 255.0f),
static_cast<uint16>(FMath::Frac(CoordsF.Y) * 255.0f));
const FIntVector2 Coords = FIntVector2(CoordsF.X, CoordsF.Y);
const FIntVector2 CoordsPlusOne = FIntVector2(
FMath::Min(Size.X - 1, Coords.X + 1),
FMath::Min(Size.Y - 1, Coords.Y + 1));
uint8 const* const Pixel00Ptr = DataPtr + (Coords.Y * Size.X + Coords.X) * PIXEL_SIZE;
uint8 const* const Pixel10Ptr = DataPtr + (Coords.Y * Size.X + CoordsPlusOne.X) * PIXEL_SIZE;
uint8 const* const Pixel01Ptr = DataPtr + (CoordsPlusOne.Y * Size.X + Coords.X) * PIXEL_SIZE;
uint8 const* const Pixel11Ptr = DataPtr + (CoordsPlusOne.Y * Size.X + CoordsPlusOne.X) * PIXEL_SIZE;
FPixelData PixelData00 = LoadPixel(Pixel00Ptr);
FPixelData PixelData10 = LoadPixel(Pixel10Ptr);
FPixelData PixelData01 = LoadPixel(Pixel01Ptr);
FPixelData PixelData11 = LoadPixel(Pixel11Ptr);
FPixelData FilteredPixelData;
for (int32 C = 0; C < PIXEL_SIZE; ++C)
{
const uint16 LerpY0 = ((PixelData10.Data[C] * Frac.X) + PixelData00.Data[C] * (255 - Frac.X)) / 255;
const uint16 LerpY1 = ((PixelData11.Data[C] * Frac.X) + PixelData01.Data[C] * (255 - Frac.X)) / 255;
FilteredPixelData.Data[C] = ((LerpY1 * Frac.Y) + LerpY0 * (255 - Frac.Y)) / 255;
}
return FilteredPixelData;
};
Result = SampleImageBilinear(Uv, FUInt16Vector2(Context.Source0SizeX, Context.Source0SizeY), Context.Source0Data);
FPixelData Sample1 = SampleImageBilinear(Uv, FUInt16Vector2(Context.Source1SizeX, Context.Source1SizeY), Context.Source1Data);
const uint16 MipFactor = static_cast<uint16>(Context.MipInterpolationFactor * 255.0f);
for (int32 C = 0; C < PIXEL_SIZE; ++C)
{
Result.Data[C] = ((Sample1.Data[C] * MipFactor) + Result.Data[C] * (255 - MipFactor)) / 255;
}
}
else if (EnumHasAnyFlags(Features, EPixelProcessorFeatures::SamplingPoint))
{
const int32 CoordX = FMath::FloorToInt32(Context.Source0SizeX * Uv.X);
const int32 CoordY = FMath::FloorToInt32(Context.Source0SizeY * Uv.Y);
Result = LoadPixel(Context.Source0Data + (CoordY*Context.Source0SizeX + CoordX) * PIXEL_SIZE);
}
static_assert(EnumHasAnyFlags(Features, EPixelProcessorFeatures::SamplingPoint | EPixelProcessorFeatures::SamplingLinear));
static_assert(PIXEL_SIZE <= 4);
// FadingEnabledMaskSeed will be -1 if enabled and 0 otherwise.
const int16 FadingMask[4] = {
static_cast<int16>(Context.RGBFadingEnabledMask),
static_cast<int16>(Context.RGBFadingEnabledMask),
static_cast<int16>(Context.RGBFadingEnabledMask),
static_cast<int16>(Context.AlphaFadingEnabledMask) };
for (int32 I = 0; I < PIXEL_SIZE; ++I)
{
BufferPos[I] = static_cast<uint8>(
(Result.Data[I] * ((MaskFactor & ~FadingMask[I]) + (Factor & FadingMask[I]))) / 255);
}
}
}
}
};
//-------------------------------------------------------------------------------------------------
FORCENOINLINE void ImageRasterProjected_Optimised(const FMesh* pMesh, FImage* pImage,
TTriangleRasterPixelProcRefType<4> PixelProc,
float FadeEnd,
UE::Math::TIntVector2<uint16> CropMin, UE::Math::TIntVector2<uint16> UncroppedSize,
FScratchImageProject* Scratch)
{
MUTABLE_CPUPROFILER_SCOPE(ImageRasterProjected_Optimised);
if (!pMesh || !pMesh->GetFaceCount())
{
return;
}
EImageFormat Format = pImage->GetFormat();
int32 PixelSize = GetImageFormatData(Format).BytesPerBlock;
int32 SizeX = pImage->GetSizeX();
int32 SizeY = pImage->GetSizeY();
bool bUseCropping = UncroppedSize[0] > 0;
// Get the vertices
int32 VertexCount = pMesh->GetVertexCount();
check((int32)Scratch->Vertices.Num() == VertexCount);
check((int32)Scratch->CulledVertex.Num() == VertexCount);
check(pMesh->GetVertexBuffers().GetElementSize(0) == sizeof(FOptimizedVertex));
const FOptimizedVertex* pVertices = reinterpret_cast<const FOptimizedVertex*>(pMesh->GetVertexBuffers().GetBufferData(0));
float FadeEndCos = FMath::Cos(FadeEnd);
for (int32 V = 0; V < VertexCount; ++V)
{
if (bUseCropping)
{
Scratch->Vertices[V].x = pVertices[V].Uv[0] * UncroppedSize[0] - CropMin[0];
Scratch->Vertices[V].y = pVertices[V].Uv[1] * UncroppedSize[1] - CropMin[1];
}
else
{
Scratch->Vertices[V].x = pVertices[V].Uv[0] * SizeX;
Scratch->Vertices[V].y = pVertices[V].Uv[1] * SizeY;
}
// TODO: No need to copy all. use scratch for the rest only.
Scratch->Vertices[V].interpolators[0] = pVertices[V].Position[0];
Scratch->Vertices[V].interpolators[1] = pVertices[V].Position[1];
Scratch->Vertices[V].interpolators[2] = pVertices[V].Position[2];
Scratch->Vertices[V].interpolators[3] = pVertices[V].Normal[0];
Scratch->CulledVertex[V] = pVertices[V].Normal[0] < FadeEndCos;
}
// Get the indices
check(pMesh->GetIndexBuffers().GetElementSize(0) == 4);
const uint32* pIndices = reinterpret_cast<const uint32*>(pMesh->GetIndexBuffers().GetBufferData(0));
// The mesh is supposed to contain only the faces in the selected block
int32 FaceCount = pMesh->GetFaceCount();
//for (int32 Face = 0; Face < FaceCount; ++Face)
ParallelFor(FaceCount, [pIndices, Scratch, SizeX, SizeY, PixelSize, pImage, PixelProc](int32 Face)
{
int32 Index0 = pIndices[Face*3 + 0];
int32 Index1 = pIndices[Face*3 + 1];
int32 Index2 = pIndices[Face*3 + 2];
// TODO: This optimisation may remove projection in the center of the face, if the angle
// range is small. Make it optional or more sophisticated (cross product may help).
if (!Scratch->CulledVertex[Index0] ||
!Scratch->CulledVertex[Index1] ||
!Scratch->CulledVertex[Index2])
{
constexpr int32 NumInterpolators = 4;
Triangle<NumInterpolators>(pImage->GetLODData(0), pImage->GetDataSize(),
SizeX, SizeY,
PixelSize,
Scratch->Vertices[Index0],
Scratch->Vertices[Index1],
Scratch->Vertices[Index2],
PixelProc,
false);
}
});
// Update the relevancy map
// \TODO: fix it to work with cropping.
if (!bUseCropping)
{
MUTABLE_CPUPROFILER_SCOPE(ImageRasterProjected_Optimised_Relevancy);
float MinY = float(SizeY) - 1.0f;
float MaxY = 0.0f;
for (int32 F = 0; F < FaceCount; ++F)
{
int32 Index0 = pIndices[F*3 + 0];
int32 Index1 = pIndices[F*3 + 1];
int32 Index2 = pIndices[F*3 + 2];
// A bit ugly, probably can be improved if integrated in above loops and made more precise
// inside the pixel processor to account for masked out pixels?
if (!Scratch->CulledVertex[Index0] ||
!Scratch->CulledVertex[Index1] ||
!Scratch->CulledVertex[Index2])
{
MinY = FMath::Min(MinY, Scratch->Vertices[Index0].y);
MinY = FMath::Min(MinY, Scratch->Vertices[Index1].y);
MinY = FMath::Min(MinY, Scratch->Vertices[Index2].y);
MaxY = FMath::Max(MaxY, Scratch->Vertices[Index0].y);
MaxY = FMath::Max(MaxY, Scratch->Vertices[Index1].y);
MaxY = FMath::Max(MaxY, Scratch->Vertices[Index2].y);
}
}
pImage->Flags |= FImage::IF_HAS_RELEVANCY_MAP;
pImage->RelevancyMinY = uint16(FMath::FloorToFloat(MinY));
pImage->RelevancyMaxY = uint16(FMath::Min( int32(FMath::CeilToFloat(MaxY)), SizeY - 1));
}
}
//-------------------------------------------------------------------------------------------------
FORCENOINLINE void ImageRasterProjected_OptimisedWrapping(const FMesh* pMesh, FImage* pImage,
TTriangleRasterPixelProcRefType<4> PixelProc,
float FadeEnd,
uint64 BlockId,
UE::Math::TIntVector2<uint16> CropMin, UE::Math::TIntVector2<uint16> UncroppedSize,
FScratchImageProject* Scratch)
{
MUTABLE_CPUPROFILER_SCOPE(ImageRasterProjected_OptimisedWrapping);
if (!pMesh || !pMesh->GetFaceCount())
{
return;
}
EImageFormat Format = pImage->GetFormat();
int32 PixelSize = GetImageFormatData(Format).BytesPerBlock;
int32 SizeX = pImage->GetSizeX();
int32 SizeY = pImage->GetSizeY();
// Get the vertices
int32 VertexCount = pMesh->GetVertexCount();
check( Scratch->Vertices.Num() == VertexCount );
check( Scratch->CulledVertex.Num() == VertexCount );
check(pMesh->GetVertexBuffers().GetElementSize(0) == sizeof(FOptimizedVertex));
const FOptimizedVertex* pVertices = reinterpret_cast<const FOptimizedVertex*>(pMesh->GetVertexBuffers().GetBufferData(0));
float FadeEndCos = FMath::Cos(FadeEnd);
// Calculate the culled flag
EMeshBufferFormat LayoutBlockType = pMesh->VertexBuffers.Buffers[1].Channels[0].Format;
switch (LayoutBlockType)
{
case EMeshBufferFormat::UInt64:
{
const uint64* LayoutBlockIds = reinterpret_cast<const uint64*>(pMesh->GetVertexBuffers().GetBufferData(1));
for (int32 V = 0; V < VertexCount; ++V)
{
// Don't cull vertices based on Normal for wrapping projectors.
//Scratch->CulledVertex[V] = pVertices[V].Normal[0] < FadeEndCos;
if (LayoutBlockIds[V] != BlockId)
{
Scratch->CulledVertex[V] = true;
}
}
break;
}
case EMeshBufferFormat::UInt16:
{
const uint16* LayoutBlockIds = reinterpret_cast<const uint16*>(pMesh->GetVertexBuffers().GetBufferData(1));
for (int32 V = 0; V < VertexCount; ++V)
{
//Scratch->CulledVertex[V] = pVertices[V].Normal[0] < FadeEndCos;
if (LayoutBlockIds[V] != BlockId)
{
Scratch->CulledVertex[V] = true;
}
}
break;
}
default:
// Not implemented?
check(false);
break;
}
for (int32 V = 0; V < VertexCount; ++V)
{
bool bUseCropping = UncroppedSize[0] > 0;
if (bUseCropping)
{
Scratch->Vertices[V].x = pVertices[V].Uv[0] * UncroppedSize[0] - CropMin[0];
Scratch->Vertices[V].y = pVertices[V].Uv[1] * UncroppedSize[1] - CropMin[1];
}
else
{
Scratch->Vertices[V].x = pVertices[V].Uv[0] * SizeX;
Scratch->Vertices[V].y = pVertices[V].Uv[1] * SizeY;
}
// TODO: No need to copy all. use scratch for the rest only.
Scratch->Vertices[V].interpolators[0] = pVertices[V].Position[0];
Scratch->Vertices[V].interpolators[1] = pVertices[V].Position[1];
Scratch->Vertices[V].interpolators[2] = pVertices[V].Position[2];
Scratch->Vertices[V].interpolators[3] = pVertices[V].Normal[0];
}
// Get the indices
check(pMesh->GetIndexBuffers().GetElementSize(0) == 4);
const uint32* pIndices = reinterpret_cast<const uint32*>(pMesh->GetIndexBuffers().GetBufferData(0));
// The mesh is supposed to contain only the faces in the selected block
int32 FaceCount = pMesh->GetFaceCount();
//for (int32 Face = 0; Face < FaceCount; ++Face)
ParallelFor(FaceCount, [pIndices, Scratch, SizeX, SizeY, PixelSize, pImage, PixelProc](int32 Face)
{
int32 Index0 = pIndices[Face*3 + 0];
int32 Index1 = pIndices[Face*3 + 1];
int32 Index2 = pIndices[Face*3 + 2];
// TODO: This optimisation may remove projection in the center of the face, if the angle
// range is small. Make it optional or more sophisticated (cross product may help).
if (!Scratch->CulledVertex[Index0] ||
!Scratch->CulledVertex[Index1] ||
!Scratch->CulledVertex[Index2])
{
constexpr int32 NumInterpolators = 4;
Triangle<NumInterpolators>(pImage->GetLODData(0), pImage->GetDataSize(),
SizeX, SizeY,
PixelSize,
Scratch->Vertices[Index0], Scratch->Vertices[Index1], Scratch->Vertices[Index2],
PixelProc,
false);
}
});
}
template <EPixelProcessorFeatures Features>
FORCENOINLINE void InvokePlanarRasterizerImpl(const FImageRasterInvokeArgs& Args)
{
static_assert(EnumHasAnyFlags(Features, EPixelProcessorFeatures::ProjectionPlanar));
const Private::FProjectedPixelProcessorContext Context =
Private::TProjectedPixelProcessor<Features>::MakeContext(
Args.SourcePtr, Args.ImagePtr->GetLODData(0), Args.MaskPtr ? Args.MaskPtr->GetLODData(0) : nullptr,
Args.bIsRGBFadingEnabled, Args.bIsAlphaFadingEnabled, Args.FadeStart, Args.FadeEnd,
Args.ProjectionAngle, Args.MipInterpolationFactor);
auto PixelProc = [&Context](uint8* Buffer, float Varying[4])
{
Private::TProjectedPixelProcessor<Features>::ProcessPixel(Context, Buffer, Varying);
};
ImageRasterProjected_Optimised(Args.MeshPtr, Args.ImagePtr, PixelProc, Args.FadeEnd, Args.CropMin, Args.UncroppedSize, Args.Scratch);
}
template <EPixelProcessorFeatures Features>
FORCENOINLINE void InvokeCylindricalRasterizerImpl(const FImageRasterInvokeArgs& Args)
{
static_assert(EnumHasAnyFlags(Features, EPixelProcessorFeatures::ProjectionCylindrical));
const Private::FProjectedPixelProcessorContext Context =
Private::TProjectedPixelProcessor<Features>::MakeContext(
Args.SourcePtr, Args.ImagePtr->GetLODData(0), Args.MaskPtr ? Args.MaskPtr->GetLODData(0) : nullptr,
Args.bIsRGBFadingEnabled, Args.bIsAlphaFadingEnabled, Args.FadeStart, Args.FadeEnd,
Args.ProjectionAngle, Args.MipInterpolationFactor);
auto PixelProc = [&Context](uint8* Buffer, float Varying[4])
{
Private::TProjectedPixelProcessor<Features>::ProcessPixel(Context, Buffer, Varying);
};
ImageRasterProjected_Optimised(Args.MeshPtr, Args.ImagePtr, PixelProc, Args.FadeEnd, Args.CropMin, Args.UncroppedSize, Args.Scratch);
}
template <EPixelProcessorFeatures Features>
FORCENOINLINE void InvokeWrappingRasterizerImpl(const FImageRasterInvokeArgs& Args)
{
static_assert(EnumHasAnyFlags(Features, EPixelProcessorFeatures::ProjectionWrap));
const Private::FProjectedPixelProcessorContext Context =
Private::TProjectedPixelProcessor<Features>::MakeContext(
Args.SourcePtr, Args.ImagePtr->GetLODData(0), Args.MaskPtr ? Args.MaskPtr->GetLODData(0) : nullptr,
Args.bIsRGBFadingEnabled, Args.bIsAlphaFadingEnabled, Args.FadeStart, Args.FadeEnd,
Args.ProjectionAngle, Args.MipInterpolationFactor);
auto PixelProc = [&Context](uint8* Buffer, float Varying[4])
{
Private::TProjectedPixelProcessor<Features>::ProcessPixel(Context, Buffer, Varying);
};
ImageRasterProjected_OptimisedWrapping(Args.MeshPtr, Args.ImagePtr, PixelProc, Args.FadeEnd, Args.BlockId, Args.CropMin, Args.UncroppedSize, Args.Scratch);
}
} // namespace Private
//-------------------------------------------------------------------------------------------------
void ImageRasterProjectedPlanar(const FMesh* pMesh, FImage* pImage,
const FImage* pSource,
const FImage* pMask,
bool bIsRGBFadingEnabled, bool bIsAlphaFadingEnabled,
ESamplingMethod SamplingMethod,
float FadeStart, float FadeEnd, float MipInterpolationFactor,
int32 Layout, uint64 BlockId,
UE::Math::TIntVector2<uint16> CropMin, UE::Math::TIntVector2<uint16> UncroppedSize,
FScratchImageProject* Scratch, bool bUseVectorImplementation)
{
using namespace mu::Private;
check(!pMask || pMask->GetSizeX() == pImage->GetSizeX());
check(!pMask || pMask->GetSizeY() == pImage->GetSizeY());
check(!pMask || pMask->GetFormat()==EImageFormat::L_UByte);
MUTABLE_CPUPROFILER_SCOPE(ImageProject);
EPixelProcessorFeatures ProcessorFeatures = EPixelProcessorFeatures::ProjectionPlanar;
// Disable vectorized implementation if Point sampling.
if (bUseVectorImplementation && SamplingMethod != ESamplingMethod::Point)
{
ProcessorFeatures |= EPixelProcessorFeatures::VectorizedImpl;
}
if (pSource->GetFormat() == EImageFormat::L_UByte)
{
ProcessorFeatures |= EPixelProcessorFeatures::FormatL;
}
else if (pSource->GetFormat() == EImageFormat::RGB_UByte)
{
ProcessorFeatures |= EPixelProcessorFeatures::FormatRGB;
}
else if (pSource->GetFormat() == EImageFormat::RGBA_UByte || pSource->GetFormat() == EImageFormat::BGRA_UByte)
{
ProcessorFeatures |= EPixelProcessorFeatures::FormatRGBA;
}
if (SamplingMethod == ESamplingMethod::Point)
{
ProcessorFeatures |= EPixelProcessorFeatures::SamplingPoint;
}
else if (SamplingMethod == ESamplingMethod::BiLinear)
{
ProcessorFeatures |= EPixelProcessorFeatures::SamplingLinear;
}
if (pMask)
{
ProcessorFeatures |= EPixelProcessorFeatures::WithMask;
}
if (EnumHasAnyFlags(pMesh->Flags, EMeshFlags::ProjectFormat))
{
float UnusedProjectionAngle = 0;
FImageRasterInvokeArgs RasterArgs =
{
pMesh, pImage, pSource, pMask,
bIsRGBFadingEnabled, bIsAlphaFadingEnabled,
SamplingMethod,
FadeStart, FadeEnd, UnusedProjectionAngle, MipInterpolationFactor,
Layout, BlockId, CropMin, UncroppedSize, Scratch
};
using EPPF = EPixelProcessorFeatures;
// This contains all the permutations, this is way more than what it was supported before
// but maybe not needed. Mask permutations can be removed safely
switch (ProcessorFeatures)
{
case (EPPF::FormatL | EPPF::ProjectionPlanar | EPPF::SamplingPoint):
{
InvokePlanarRasterizerImpl<EPPF::FormatL | EPPF::ProjectionPlanar | EPPF::SamplingPoint>(RasterArgs);
break;
}
case (EPPF::FormatRGB | EPPF::ProjectionPlanar | EPPF::SamplingPoint):
{
InvokePlanarRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionPlanar | EPPF::SamplingPoint>(RasterArgs);
break;
}
case (EPPF::FormatRGBA | EPPF::ProjectionPlanar | EPPF::SamplingPoint):
{
InvokePlanarRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionPlanar | EPPF::SamplingPoint>(RasterArgs);
break;
}
case (EPPF::FormatL | EPPF::ProjectionPlanar | EPPF::SamplingLinear):
{
InvokePlanarRasterizerImpl<EPPF::FormatL | EPPF::ProjectionPlanar | EPPF::SamplingLinear>(RasterArgs);
break;
}
case (EPPF::FormatRGB | EPPF::ProjectionPlanar | EPPF::SamplingLinear):
{
InvokePlanarRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionPlanar | EPPF::SamplingLinear>(RasterArgs);
break;
}
case (EPPF::FormatRGBA | EPPF::ProjectionPlanar | EPPF::SamplingLinear):
{
InvokePlanarRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionPlanar | EPPF::SamplingLinear>(RasterArgs);
break;
}
case (EPPF::FormatL | EPPF::ProjectionPlanar | EPPF::SamplingPoint | EPPF::WithMask):
{
InvokePlanarRasterizerImpl<EPPF::FormatL | EPPF::ProjectionPlanar | EPPF::SamplingPoint | EPPF::WithMask>(RasterArgs);
break;
}
case (EPPF::FormatRGB | EPPF::ProjectionPlanar | EPPF::SamplingPoint | EPPF::WithMask):
{
InvokePlanarRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionPlanar | EPPF::SamplingPoint | EPPF::WithMask>(RasterArgs);
break;
}
case (EPPF::FormatRGBA | EPPF::ProjectionPlanar | EPPF::SamplingPoint | EPPF::WithMask):
{
InvokePlanarRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionPlanar | EPPF::SamplingPoint>(RasterArgs);
break;
}
case (EPPF::FormatL | EPPF::ProjectionPlanar | EPPF::SamplingLinear | EPPF::WithMask):
{
InvokePlanarRasterizerImpl<EPPF::FormatL | EPPF::ProjectionPlanar | EPPF::SamplingLinear | EPPF::WithMask>(RasterArgs);
break;
}
case (EPPF::FormatRGB | EPPF::ProjectionPlanar | EPPF::SamplingLinear | EPPF::WithMask):
{
InvokePlanarRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionPlanar | EPPF::SamplingLinear | EPPF::WithMask>(RasterArgs);
break;
}
case (EPPF::FormatRGBA | EPPF::ProjectionPlanar | EPPF::SamplingLinear | EPPF::WithMask):
{
InvokePlanarRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionPlanar | EPPF::SamplingLinear | EPPF::WithMask>(RasterArgs);
break;
}
//case (EPPF::FormatL | EPPF::ProjectionPlanar | EPPF::SamplingPoint | EPPF::VectorizedImpl):
//{
// InvokePlanarRasterizerImpl<EPPF::FormatL | EPPF::ProjectionPlanar | EPPF::SamplingPoint | EPPF::VectorizedImpl>(RasterArgs);
// break;
//}
//case (EPPF::FormatRGB | EPPF::ProjectionPlanar | EPPF::SamplingPoint | EPPF::VectorizedImpl):
//{
// InvokePlanarRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionPlanar | EPPF::SamplingPoint | EPPF::VectorizedImpl>(RasterArgs);
// break;
//}
//case (EPPF::FormatRGBA | EPPF::ProjectionPlanar | EPPF::SamplingPoint | EPPF::VectorizedImpl):
//{
// InvokePlanarRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionPlanar | EPPF::SamplingPoint | EPPF::VectorizedImpl>(RasterArgs);
// break;
//}
case (EPPF::FormatL | EPPF::ProjectionPlanar | EPPF::SamplingLinear | EPPF::VectorizedImpl):
{
InvokePlanarRasterizerImpl<EPPF::FormatL | EPPF::ProjectionPlanar | EPPF::SamplingLinear | EPPF::VectorizedImpl>(RasterArgs);
break;
}
case (EPPF::FormatRGB | EPPF::ProjectionPlanar | EPPF::SamplingLinear | EPPF::VectorizedImpl):
{
InvokePlanarRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionPlanar | EPPF::SamplingLinear | EPPF::VectorizedImpl>(RasterArgs);
break;
}
case (EPPF::FormatRGBA | EPPF::ProjectionPlanar | EPPF::SamplingLinear | EPPF::VectorizedImpl):
{
InvokePlanarRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionPlanar | EPPF::SamplingLinear | EPPF::VectorizedImpl>(RasterArgs);
break;
}
//case (EPPF::FormatL | EPPF::ProjectionPlanar | EPPF::SamplingPoint | EPPF::WithMask | EPPF::VectorizedImpl):
//{
// InvokePlanarRasterizerImpl<EPPF::FormatL | EPPF::ProjectionPlanar | EPPF::SamplingPoint | EPPF::WithMask | EPPF::VectorizedImpl>(RasterArgs);
// break;
//}
//case (EPPF::FormatRGB | EPPF::ProjectionPlanar | EPPF::SamplingPoint | EPPF::WithMask | EPPF::VectorizedImpl):
//{
// InvokePlanarRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionPlanar | EPPF::SamplingPoint | EPPF::WithMask | EPPF::VectorizedImpl>(RasterArgs);
// break;
//}
//case (EPPF::FormatRGBA | EPPF::ProjectionPlanar | EPPF::SamplingPoint | EPPF::WithMask | EPPF::VectorizedImpl):
//{
// InvokePlanarRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionPlanar | EPPF::SamplingPoint | EPPF::VectorizedImpl>(RasterArgs);
// break;
//}
case (EPPF::FormatL | EPPF::ProjectionPlanar | EPPF::SamplingLinear | EPPF::WithMask | EPPF::VectorizedImpl):
{
InvokePlanarRasterizerImpl<EPPF::FormatL | EPPF::ProjectionPlanar | EPPF::SamplingLinear | EPPF::WithMask | EPPF::VectorizedImpl>(RasterArgs);
break;
}
case (EPPF::FormatRGB | EPPF::ProjectionPlanar | EPPF::SamplingLinear | EPPF::WithMask | EPPF::VectorizedImpl):
{
InvokePlanarRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionPlanar | EPPF::SamplingLinear | EPPF::WithMask>(RasterArgs);
break;
}
case (EPPF::FormatRGBA | EPPF::ProjectionPlanar | EPPF::SamplingLinear | EPPF::WithMask | EPPF::VectorizedImpl):
{
InvokePlanarRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionPlanar | EPPF::SamplingLinear | EPPF::WithMask | EPPF::VectorizedImpl>(RasterArgs);
break;
}
default:
{
checkf(false, TEXT("Planar raster pixel processor permutation not implemented."));
}
};
}
else
{
check(false);
}
}
//-------------------------------------------------------------------------------------------------
void ImageRasterProjectedWrapping( const FMesh* pMesh, FImage* pImage,
const FImage* pSource, const FImage* pMask,
bool bIsRGBFadingEnabled, bool bIsAlphaFadingEnabled,
ESamplingMethod SamplingMethod,
float FadeStart, float FadeEnd, float MipInterpolationFactor,
int32 Layout, uint64 BlockId,
UE::Math::TIntVector2<uint16> CropMin, UE::Math::TIntVector2<uint16> UncroppedSize,
FScratchImageProject* Scratch, bool bUseVectorImplementation)
{
using namespace mu::Private;
check(!pMask || pMask->GetSizeX() == pImage->GetSizeX());
check(!pMask || pMask->GetSizeY() == pImage->GetSizeY());
check(!pMask || pMask->GetFormat()==EImageFormat::L_UByte);
MUTABLE_CPUPROFILER_SCOPE(ImageProjectWrapping);
EPixelProcessorFeatures ProcessorFeatures = EPixelProcessorFeatures::ProjectionWrap;
if (bUseVectorImplementation && SamplingMethod != ESamplingMethod::Point)
{
ProcessorFeatures |= EPixelProcessorFeatures::VectorizedImpl;
}
if (pSource->GetFormat() == EImageFormat::L_UByte)
{
ProcessorFeatures |= EPixelProcessorFeatures::FormatL;
}
else if (pSource->GetFormat() == EImageFormat::RGB_UByte)
{
ProcessorFeatures |= EPixelProcessorFeatures::FormatRGB;
}
else if (pSource->GetFormat() == EImageFormat::RGBA_UByte || pSource->GetFormat() == EImageFormat::BGRA_UByte)
{
ProcessorFeatures |= EPixelProcessorFeatures::FormatRGBA;
}
if (SamplingMethod == ESamplingMethod::Point)
{
ProcessorFeatures |= EPixelProcessorFeatures::SamplingPoint;
}
else if (SamplingMethod == ESamplingMethod::BiLinear)
{
ProcessorFeatures |= EPixelProcessorFeatures::SamplingLinear;
}
if (pMask)
{
ProcessorFeatures |= EPixelProcessorFeatures::WithMask;
}
if (EnumHasAnyFlags(pMesh->Flags, EMeshFlags::ProjectWrappingFormat))
{
float UnusedProjectionAngle = 0;
FImageRasterInvokeArgs RasterArgs =
{
pMesh, pImage, pSource, pMask,
bIsRGBFadingEnabled, bIsAlphaFadingEnabled,
SamplingMethod,
FadeStart, FadeEnd, UnusedProjectionAngle, MipInterpolationFactor,
Layout, BlockId, CropMin, UncroppedSize, Scratch
};
using EPPF = EPixelProcessorFeatures;
// This contains all the permutations, this is way more than what it was supported before
// but maybe not needed. Mask permutations can be removed safely
switch (ProcessorFeatures)
{
case (EPPF::FormatL | EPPF::ProjectionWrap | EPPF::SamplingPoint):
{
InvokeWrappingRasterizerImpl<EPPF::FormatL | EPPF::ProjectionWrap | EPPF::SamplingPoint>(RasterArgs);
break;
}
case (EPPF::FormatRGB | EPPF::ProjectionWrap | EPPF::SamplingPoint):
{
InvokeWrappingRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionWrap | EPPF::SamplingPoint>(RasterArgs);
break;
}
case (EPPF::FormatRGBA | EPPF::ProjectionWrap | EPPF::SamplingPoint):
{
InvokeWrappingRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionWrap | EPPF::SamplingPoint>(RasterArgs);
break;
}
case (EPPF::FormatL | EPPF::ProjectionWrap | EPPF::SamplingLinear):
{
InvokeWrappingRasterizerImpl<EPPF::FormatL | EPPF::ProjectionWrap | EPPF::SamplingLinear>(RasterArgs);
break;
}
case (EPPF::FormatRGB | EPPF::ProjectionWrap | EPPF::SamplingLinear):
{
InvokeWrappingRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionWrap | EPPF::SamplingLinear>(RasterArgs);
break;
}
case (EPPF::FormatRGBA | EPPF::ProjectionWrap | EPPF::SamplingLinear):
{
InvokeWrappingRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionWrap | EPPF::SamplingLinear>(RasterArgs);
break;
}
case (EPPF::FormatL | EPPF::ProjectionWrap | EPPF::SamplingPoint | EPPF::WithMask):
{
InvokeWrappingRasterizerImpl<EPPF::FormatL | EPPF::ProjectionWrap | EPPF::SamplingPoint | EPPF::WithMask>(RasterArgs);
break;
}
case (EPPF::FormatRGB | EPPF::ProjectionWrap | EPPF::SamplingPoint | EPPF::WithMask):
{
InvokeWrappingRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionWrap | EPPF::SamplingPoint | EPPF::WithMask>(RasterArgs);
break;
}
case (EPPF::FormatRGBA | EPPF::ProjectionWrap | EPPF::SamplingPoint | EPPF::WithMask):
{
InvokeWrappingRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionWrap | EPPF::SamplingPoint>(RasterArgs);
break;
}
case (EPPF::FormatL | EPPF::ProjectionWrap | EPPF::SamplingLinear | EPPF::WithMask):
{
InvokeWrappingRasterizerImpl<EPPF::FormatL | EPPF::ProjectionWrap | EPPF::SamplingLinear | EPPF::WithMask>(RasterArgs);
break;
}
case (EPPF::FormatRGB | EPPF::ProjectionWrap | EPPF::SamplingLinear | EPPF::WithMask):
{
InvokeWrappingRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionWrap | EPPF::SamplingLinear | EPPF::WithMask>(RasterArgs);
break;
}
case (EPPF::FormatRGBA | EPPF::ProjectionWrap | EPPF::SamplingLinear | EPPF::WithMask):
{
InvokeWrappingRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionWrap | EPPF::SamplingLinear | EPPF::WithMask>(RasterArgs);
break;
}
//case (EPPF::FormatL | EPPF::ProjectionWrap | EPPF::SamplingPoint | EPPF::VectorizedImpl):
//{
// InvokeWrappingRasterizerImpl<EPPF::FormatL | EPPF::ProjectionWrap | EPPF::SamplingPoint | EPPF::VectorizedImpl>(RasterArgs);
// break;
//}
//case (EPPF::FormatRGB | EPPF::ProjectionWrap | EPPF::SamplingPoint | EPPF::VectorizedImpl):
//{
// InvokeWrappingRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionWrap | EPPF::SamplingPoint | EPPF::VectorizedImpl>(RasterArgs);
// break;
//}
//case (EPPF::FormatRGBA | EPPF::ProjectionWrap | EPPF::SamplingPoint | EPPF::VectorizedImpl):
//{
// InvokeWrappingRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionWrap | EPPF::SamplingPoint | EPPF::VectorizedImpl>(RasterArgs);
// break;
//}
case (EPPF::FormatL | EPPF::ProjectionWrap | EPPF::SamplingLinear | EPPF::VectorizedImpl):
{
InvokeWrappingRasterizerImpl<EPPF::FormatL | EPPF::ProjectionWrap | EPPF::SamplingLinear | EPPF::VectorizedImpl>(RasterArgs);
break;
}
case (EPPF::FormatRGB | EPPF::ProjectionWrap | EPPF::SamplingLinear | EPPF::VectorizedImpl):
{
InvokeWrappingRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionWrap | EPPF::SamplingLinear | EPPF::VectorizedImpl>(RasterArgs);
break;
}
case (EPPF::FormatRGBA | EPPF::ProjectionWrap | EPPF::SamplingLinear | EPPF::VectorizedImpl):
{
InvokeWrappingRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionWrap | EPPF::SamplingLinear | EPPF::VectorizedImpl>(RasterArgs);
break;
}
//case (EPPF::FormatL | EPPF::ProjectionWrap | EPPF::SamplingPoint | EPPF::WithMask | EPPF::VectorizedImpl):
//{
// InvokeWrappingRasterizerImpl<EPPF::FormatL | EPPF::ProjectionWrap | EPPF::SamplingPoint | EPPF::WithMask | EPPF::VectorizedImpl>(RasterArgs);
// break;
//}
//case (EPPF::FormatRGB | EPPF::ProjectionWrap | EPPF::SamplingPoint | EPPF::WithMask | EPPF::VectorizedImpl):
//{
// InvokeWrappingRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionWrap | EPPF::SamplingPoint | EPPF::WithMask | EPPF::VectorizedImpl>(RasterArgs);
// break;
//}
//case (EPPF::FormatRGBA | EPPF::ProjectionWrap | EPPF::SamplingPoint | EPPF::WithMask | EPPF::VectorizedImpl):
//{
// InvokeWrappingRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionWrap | EPPF::SamplingPoint | EPPF::VectorizedImpl>(RasterArgs);
// break;
//}
case (EPPF::FormatL | EPPF::ProjectionWrap | EPPF::SamplingLinear | EPPF::WithMask | EPPF::VectorizedImpl):
{
InvokeWrappingRasterizerImpl<EPPF::FormatL | EPPF::ProjectionWrap | EPPF::SamplingLinear | EPPF::WithMask | EPPF::VectorizedImpl>(RasterArgs);
break;
}
case (EPPF::FormatRGB | EPPF::ProjectionWrap | EPPF::SamplingLinear | EPPF::WithMask | EPPF::VectorizedImpl):
{
InvokeWrappingRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionWrap | EPPF::SamplingLinear | EPPF::WithMask>(RasterArgs);
break;
}
case (EPPF::FormatRGBA | EPPF::ProjectionWrap | EPPF::SamplingLinear | EPPF::WithMask | EPPF::VectorizedImpl):
{
InvokeWrappingRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionWrap | EPPF::SamplingLinear | EPPF::WithMask | EPPF::VectorizedImpl>(RasterArgs);
break;
}
default:
{
checkf(false, TEXT("Wrapping projection raster pixel processor permutation not implemented."));
}
};
}
else
{
check(false);
}
}
//-------------------------------------------------------------------------------------------------
void ImageRasterProjectedCylindrical( const FMesh* pMesh, FImage* pImage,
const FImage* pSource, const FImage* pMask,
bool bIsRGBFadingEnabled, bool bIsAlphaFadingEnabled,
ESamplingMethod SamplingMethod,
float FadeStart, float FadeEnd, float MipInterpolationFactor,
int32 /*layout*/,
float ProjectionAngle,
UE::Math::TIntVector2<uint16> CropMin, UE::Math::TIntVector2<uint16> UncroppedSize,
FScratchImageProject* Scratch, bool bUseVectorImplementation)
{
using namespace mu::Private;
check(!pMask || pMask->GetSizeX() == pImage->GetSizeX());
check(!pMask || pMask->GetSizeY() == pImage->GetSizeY());
check(!pMask || pMask->GetFormat()==EImageFormat::L_UByte);
MUTABLE_CPUPROFILER_SCOPE(ImageProjectCylindrical);
EPixelProcessorFeatures ProcessorFeatures = EPixelProcessorFeatures::ProjectionCylindrical;
if (bUseVectorImplementation && SamplingMethod != ESamplingMethod::Point)
{
ProcessorFeatures |= EPixelProcessorFeatures::VectorizedImpl;
}
if (pSource->GetFormat() == EImageFormat::L_UByte)
{
ProcessorFeatures |= EPixelProcessorFeatures::FormatL;
}
else if (pSource->GetFormat() == EImageFormat::RGB_UByte)
{
ProcessorFeatures |= EPixelProcessorFeatures::FormatRGB;
}
else if (pSource->GetFormat() == EImageFormat::RGBA_UByte || pSource->GetFormat() == EImageFormat::BGRA_UByte)
{
ProcessorFeatures |= EPixelProcessorFeatures::FormatRGBA;
}
if (SamplingMethod == ESamplingMethod::Point)
{
ProcessorFeatures |= EPixelProcessorFeatures::SamplingPoint;
}
else if (SamplingMethod == ESamplingMethod::BiLinear)
{
ProcessorFeatures |= EPixelProcessorFeatures::SamplingLinear;
}
if (pMask)
{
ProcessorFeatures |= EPixelProcessorFeatures::WithMask;
}
if (EnumHasAnyFlags(pMesh->Flags, EMeshFlags::ProjectFormat))
{
int32 UnusedLayout = 0;
int32 UnusedBlock = 0;
FImageRasterInvokeArgs RasterArgs =
{
pMesh, pImage, pSource, pMask,
bIsRGBFadingEnabled, bIsAlphaFadingEnabled,
SamplingMethod,
FadeStart, FadeEnd, ProjectionAngle, MipInterpolationFactor,
UnusedLayout, UnusedBlock, CropMin, UncroppedSize, Scratch
};
using EPPF = EPixelProcessorFeatures;
// This contains all the permutations, this is way more than what it was supported before
// but maybe not needed. Mask permutations can be removed safely
switch (ProcessorFeatures)
{
case (EPPF::FormatL | EPPF::ProjectionCylindrical | EPPF::SamplingPoint):
{
InvokeCylindricalRasterizerImpl<EPPF::FormatL | EPPF::ProjectionCylindrical | EPPF::SamplingPoint>(RasterArgs);
break;
}
case (EPPF::FormatRGB | EPPF::ProjectionCylindrical | EPPF::SamplingPoint):
{
InvokeCylindricalRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionCylindrical | EPPF::SamplingPoint>(RasterArgs);
break;
}
case (EPPF::FormatRGBA | EPPF::ProjectionCylindrical | EPPF::SamplingPoint):
{
InvokeCylindricalRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionCylindrical | EPPF::SamplingPoint>(RasterArgs);
break;
}
case (EPPF::FormatL | EPPF::ProjectionCylindrical | EPPF::SamplingLinear):
{
InvokeCylindricalRasterizerImpl<EPPF::FormatL | EPPF::ProjectionCylindrical | EPPF::SamplingLinear>(RasterArgs);
break;
}
case (EPPF::FormatRGB | EPPF::ProjectionCylindrical | EPPF::SamplingLinear):
{
InvokeCylindricalRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionCylindrical | EPPF::SamplingLinear>(RasterArgs);
break;
}
case (EPPF::FormatRGBA | EPPF::ProjectionCylindrical | EPPF::SamplingLinear):
{
InvokeCylindricalRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionCylindrical | EPPF::SamplingLinear>(RasterArgs);
break;
}
case (EPPF::FormatL | EPPF::ProjectionCylindrical | EPPF::SamplingPoint | EPPF::WithMask):
{
InvokeCylindricalRasterizerImpl<EPPF::FormatL | EPPF::ProjectionCylindrical | EPPF::SamplingPoint | EPPF::WithMask>(RasterArgs);
break;
}
case (EPPF::FormatRGB | EPPF::ProjectionCylindrical | EPPF::SamplingPoint | EPPF::WithMask):
{
InvokeCylindricalRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionCylindrical | EPPF::SamplingPoint | EPPF::WithMask>(RasterArgs);
break;
}
case (EPPF::FormatRGBA | EPPF::ProjectionCylindrical | EPPF::SamplingPoint | EPPF::WithMask):
{
InvokeCylindricalRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionCylindrical | EPPF::SamplingPoint>(RasterArgs);
break;
}
case (EPPF::FormatL | EPPF::ProjectionCylindrical | EPPF::SamplingLinear | EPPF::WithMask):
{
InvokeCylindricalRasterizerImpl<EPPF::FormatL | EPPF::ProjectionCylindrical | EPPF::SamplingLinear | EPPF::WithMask>(RasterArgs);
break;
}
case (EPPF::FormatRGB | EPPF::ProjectionCylindrical | EPPF::SamplingLinear | EPPF::WithMask):
{
InvokeCylindricalRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionCylindrical | EPPF::SamplingLinear | EPPF::WithMask>(RasterArgs);
break;
}
case (EPPF::FormatRGBA | EPPF::ProjectionCylindrical | EPPF::SamplingLinear | EPPF::WithMask):
{
InvokeCylindricalRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionCylindrical | EPPF::SamplingLinear | EPPF::WithMask>(RasterArgs);
break;
}
//case (EPPF::FormatL | EPPF::ProjectionCylindrical | EPPF::SamplingPoint | EPPF::VectorizedImpl):
//{
// InvokeCylindricalRasterizerImpl<EPPF::FormatL | EPPF::ProjectionCylindrical | EPPF::SamplingPoint | EPPF::VectorizedImpl>(RasterArgs);
// break;
//}
//case (EPPF::FormatRGB | EPPF::ProjectionCylindrical | EPPF::SamplingPoint | EPPF::VectorizedImpl):
//{
// InvokeCylindricalRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionCylindrical | EPPF::SamplingPoint | EPPF::VectorizedImpl>(RasterArgs);
// break;
//}
//case (EPPF::FormatRGBA | EPPF::ProjectionCylindrical | EPPF::SamplingPoint | EPPF::VectorizedImpl):
//{
// InvokeCylindricalRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionCylindrical | EPPF::SamplingPoint | EPPF::VectorizedImpl>(RasterArgs);
// break;
//}
case (EPPF::FormatL | EPPF::ProjectionCylindrical | EPPF::SamplingLinear | EPPF::VectorizedImpl):
{
InvokeCylindricalRasterizerImpl<EPPF::FormatL | EPPF::ProjectionCylindrical | EPPF::SamplingLinear | EPPF::VectorizedImpl>(RasterArgs);
break;
}
case (EPPF::FormatRGB | EPPF::ProjectionCylindrical | EPPF::SamplingLinear | EPPF::VectorizedImpl):
{
InvokeCylindricalRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionCylindrical | EPPF::SamplingLinear | EPPF::VectorizedImpl>(RasterArgs);
break;
}
case (EPPF::FormatRGBA | EPPF::ProjectionCylindrical | EPPF::SamplingLinear | EPPF::VectorizedImpl):
{
InvokeCylindricalRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionCylindrical | EPPF::SamplingLinear | EPPF::VectorizedImpl>(RasterArgs);
break;
}
//case (EPPF::FormatL | EPPF::ProjectionCylindrical | EPPF::SamplingPoint | EPPF::WithMask | EPPF::VectorizedImpl):
//{
// InvokeCylindricalRasterizerImpl<EPPF::FormatL | EPPF::ProjectionCylindrical | EPPF::SamplingPoint | EPPF::WithMask | EPPF::VectorizedImpl>(RasterArgs);
// break;
//}
//case (EPPF::FormatRGB | EPPF::ProjectionCylindrical | EPPF::SamplingPoint | EPPF::WithMask | EPPF::VectorizedImpl):
//{
// InvokeCylindricalRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionCylindrical | EPPF::SamplingPoint | EPPF::WithMask | EPPF::VectorizedImpl>(RasterArgs);
// break;
//}
//case (EPPF::FormatRGBA | EPPF::ProjectionCylindrical | EPPF::SamplingPoint | EPPF::WithMask | EPPF::VectorizedImpl):
//{
// InvokeCylindricalRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionCylindrical | EPPF::SamplingPoint | EPPF::VectorizedImpl>(RasterArgs);
// break;
//}
case (EPPF::FormatL | EPPF::ProjectionCylindrical | EPPF::SamplingLinear | EPPF::WithMask | EPPF::VectorizedImpl):
{
InvokeCylindricalRasterizerImpl<EPPF::FormatL | EPPF::ProjectionCylindrical | EPPF::SamplingLinear | EPPF::WithMask | EPPF::VectorizedImpl>(RasterArgs);
break;
}
case (EPPF::FormatRGB | EPPF::ProjectionCylindrical | EPPF::SamplingLinear | EPPF::WithMask | EPPF::VectorizedImpl):
{
InvokeCylindricalRasterizerImpl<EPPF::FormatRGB | EPPF::ProjectionCylindrical | EPPF::SamplingLinear | EPPF::WithMask>(RasterArgs);
break;
}
case (EPPF::FormatRGBA | EPPF::ProjectionCylindrical | EPPF::SamplingLinear | EPPF::WithMask | EPPF::VectorizedImpl):
{
InvokeCylindricalRasterizerImpl<EPPF::FormatRGBA | EPPF::ProjectionCylindrical | EPPF::SamplingLinear | EPPF::WithMask | EPPF::VectorizedImpl>(RasterArgs);
break;
}
default:
{
checkf(false, TEXT("Cylindrical projection raster pixel processor permutation not implemented."));
}
}
}
else
{
check(false);
}
}
float ComputeProjectedFootprintBestMip(
const FMesh* pMesh, const FProjector& Projector, const FVector2f& TargetSize, const FVector2f& SourceSize)
{
// Compute projected mesh footprint on the traget image and extract a optimal mip for source image.
const bool bIsPlanarProjection = Projector.type == EProjectorType::Planar;
const bool bIsCylindicalProjection = Projector.type == EProjectorType::Cylindrical;
const bool bIsWrappingProjection = Projector.type == EProjectorType::Wrapping;
check(pMesh->GetIndexBuffers().GetElementSize(0) == sizeof(uint32));
const uint32* IndicesPtr = reinterpret_cast<const uint32*>(pMesh->GetIndexBuffers().GetBufferData(0));
const uint32 NumIndices = pMesh->GetIndexBuffers().GetElementCount();
// Source area is the fraction of source image that is covered by the projected mesh.
float SourceArea = UE_KINDA_SMALL_NUMBER;
// Target area is the fraction of the target image that is covered by the projected mesh.
float TargetArea = UE_KINDA_SMALL_NUMBER;
auto ComputeTriangleArea = [](const FVector2f& A, const FVector2f& B, const FVector2f& C) -> float
{
return (A.X * (B.Y - C.Y) + B.X * (C.Y - A.Y) + C.X * (A.Y - B.Y)) * 0.5f;
};
check(NumIndices % 3 == 0);
// TODO: evaluate other strategies to get a better mip estimate. Maybe use the median of area change?
if (bIsPlanarProjection)
{
check(pMesh->GetVertexBuffers().GetElementSize(0) == sizeof(FOptimizedVertex));
const FOptimizedVertex* VerticesPtr =
reinterpret_cast<const FOptimizedVertex*>(pMesh->GetVertexBuffers().GetBufferData(0));
check(NumIndices % 3 == 0);
for (uint32 I = 0; I < NumIndices; I += 3)
{
const FOptimizedVertex& A = VerticesPtr[IndicesPtr[I + 0]];
const FOptimizedVertex& B = VerticesPtr[IndicesPtr[I + 1]];
const FOptimizedVertex& C = VerticesPtr[IndicesPtr[I + 2]];
const float TriangleSourceArea = ComputeTriangleArea(
FVector2f(A.Position.X, A.Position.Y), FVector2f(B.Position.X, B.Position.Y), FVector2f(C.Position.X, C.Position.Y));
const float TriangleTargetArea = ComputeTriangleArea(A.Uv, B.Uv, C.Uv);
// Set weight to zero if source or target area are close to zero to remove outliers.
float TriangleWeight = static_cast<float>(!FMath::IsNearlyZero(TriangleSourceArea)) *
static_cast<float>(!FMath::IsNearlyZero(TriangleTargetArea));
TriangleWeight *= FMath::Clamp((A.Normal.X + B.Normal.X + C.Normal.X) * (1.0f / 3.0f), 0.0f, 1.0f);
SourceArea += TriangleSourceArea * TriangleWeight;
TargetArea += TriangleTargetArea * TriangleWeight;
}
}
else if (bIsCylindicalProjection)
{
check(pMesh->GetVertexBuffers().GetElementSize(0) == sizeof(FOptimizedVertex));
const FOptimizedVertex* VerticesPtr =
reinterpret_cast<const FOptimizedVertex*>(pMesh->GetVertexBuffers().GetBufferData(0));
check(NumIndices % 3 == 0);
for (uint32 I = 0; I < NumIndices; I += 3)
{
const FOptimizedVertex& A = VerticesPtr[IndicesPtr[I + 0]];
const FOptimizedVertex& B = VerticesPtr[IndicesPtr[I + 1]];
const FOptimizedVertex& C = VerticesPtr[IndicesPtr[I + 2]];
const float ClampedProjectorAngleRad = FMath::Clamp(Projector.projectionAngle, 0.0f, UE_TWO_PI);
const float OneOverProjectionAngleSafe = !FMath::IsNearlyZero(ClampedProjectorAngleRad)
? 1.0f / Projector.projectionAngle
: 1.0f / KINDA_SMALL_NUMBER;
const FVector2f PosA = FVector2f((FMath::Atan2(A.Position.Z, -A.Position.Y) + UE_PI) * OneOverProjectionAngleSafe, A.Position.X);
const FVector2f PosB = FVector2f((FMath::Atan2(B.Position.Z, -B.Position.Y) + UE_PI) * OneOverProjectionAngleSafe, B.Position.X);
const FVector2f PosC = FVector2f((FMath::Atan2(C.Position.Z, -C.Position.Y) + UE_PI) * OneOverProjectionAngleSafe, C.Position.X);
const float TriangleSourceArea = FMath::Abs(ComputeTriangleArea(PosA, PosB, PosC));
const float TriangleTargetArea = FMath::Abs(ComputeTriangleArea(A.Uv, B.Uv, C.Uv));
// Set weight to zero if source or target area are close to zero to remove outliers.
float TriangleWeight = static_cast<float>(!FMath::IsNearlyZero(TriangleSourceArea)) *
static_cast<float>(!FMath::IsNearlyZero(TriangleTargetArea));
SourceArea += TriangleSourceArea * TriangleWeight;
TargetArea += TriangleTargetArea * TriangleWeight;
}
}
else if (bIsWrappingProjection)
{
check(pMesh->GetVertexBuffers().GetElementSize(0) == sizeof(FOptimizedVertex));
const FOptimizedVertex* VerticesPtr = reinterpret_cast<const FOptimizedVertex*>(pMesh->GetVertexBuffers().GetBufferData(0));
check(NumIndices % 3 == 0);
for (uint32 I = 0; I < NumIndices; I += 3)
{
const FOptimizedVertex& A = VerticesPtr[IndicesPtr[I + 0]];
const FOptimizedVertex& B = VerticesPtr[IndicesPtr[I + 1]];
const FOptimizedVertex& C = VerticesPtr[IndicesPtr[I + 2]];
TargetArea += ComputeTriangleArea(A.Uv, B.Uv, C.Uv);
}
SourceArea = TargetArea;
}
else
{
check(false);
}
const float SourceFootprintAreaOnTarget = TargetArea * (1.0f / SourceArea);
const float SourceFootprintAreaOnTargetInPixelsSquared =
SourceFootprintAreaOnTarget * (TargetSize.X * TargetSize.Y);
// Find the mip that better adapts to the footprint.
float BestMip = FMath::Log2(FMath::Max(1.0f, SourceSize.X * SourceSize.Y)) * 0.5f -
FMath::Log2(FMath::Max(1.0f, SourceFootprintAreaOnTargetInPixelsSquared)) * 0.5f;
return BestMip;
}
//#define DEBUG_PROJECTION 1
#ifdef DEBUG_PROJECTION
UE_DISABLE_OPTIMIZATION
#undef assert
int32* assert_aux = 0;
#define assert(x) if((x) == 0) assert_aux[0] = 1;
#endif
constexpr float vert_collapse_eps = 0.0001f;
//---------------------------------------------------------------------------------------------
//! Create a map from vertices into vertices, collapsing vertices that have the same position
//---------------------------------------------------------------------------------------------
inline void MeshCreateCollapsedVertexMap( const FMesh* pMesh,
TArray<int32>& CollapsedVertices,
TMultiMap<int32, int32>& CollapsedVerticesMap,
TArray<FVector3f>& OutVertices)
{
MUTABLE_CPUPROFILER_SCOPE(CreateCollapseMap);
const int32 NumVertices = pMesh->GetVertexCount();
// Used to speed up vertex comparison
UE::Geometry::TPointHashGrid3f<int32> VertHash(0.01f, INDEX_NONE);
VertHash.Reserve(NumVertices);
// Info to collect. Vertices, collapsed vertices and unique vertices to nearby vertices map
OutVertices.SetNumUninitialized(NumVertices);
CollapsedVertices.Init(INDEX_NONE, NumVertices);
CollapsedVerticesMap.Reserve(NumVertices);
// Get Vertices
mu::UntypedMeshBufferIteratorConst ItPosition = mu::UntypedMeshBufferIteratorConst(pMesh->GetVertexBuffers(), mu::EMeshBufferSemantic::Position);
FVector3f* VertexData = OutVertices.GetData();
for (int32 VertexIndex = 0; VertexIndex < NumVertices; ++VertexIndex)
{
*VertexData = ItPosition.GetAsVec3f();
VertHash.InsertPointUnsafe(VertexIndex, *VertexData);
++ItPosition;
++VertexData;
}
// Find unique vertices
TArray<int32> NearbyVertices;
for (int32 VertexIndex = 0; VertexIndex < NumVertices; ++VertexIndex)
{
if (CollapsedVertices[VertexIndex] != INDEX_NONE)
{
continue;
}
const FVector3f& Vertex = OutVertices[VertexIndex];
NearbyVertices.Reset();
VertHash.FindPointsInBall(Vertex, vert_collapse_eps,
[&Vertex, &OutVertices](const int32& Other) -> float {return FVector3f::DistSquared(OutVertices[Other], Vertex); },
NearbyVertices);
for (int32 NearbyVertexIndex : NearbyVertices)
{
CollapsedVertices[NearbyVertexIndex] = VertexIndex;
CollapsedVerticesMap.Add(VertexIndex, NearbyVertexIndex);
}
}
}
struct AdjacentFaces
{
int32 faces[3];
int32 newVertices[3];
bool changesUVIsland[3];
AdjacentFaces()
{
faces[0] = -1;
faces[1] = -1;
faces[2] = -1;
newVertices[0] = -1;
newVertices[1] = -1;
newVertices[2] = -1;
changesUVIsland[0] = false;
changesUVIsland[1] = false;
changesUVIsland[2] = false;
}
void addConnectedFace(int32 newConnectedFace, int32 newVertex, bool changesUVIslandParam)
{
#ifdef DEBUG_PROJECTION
assert( newConnectedFace >= 0 );
#endif
for (int32 i = 0; i < 3; ++i)
{
if (faces[i] == newConnectedFace)
{
return;
}
}
for (int32 i = 0; i < 3; ++i)
{
if (faces[i] == -1)
{
faces[i] = newConnectedFace;
newVertices[i] = newVertex;
changesUVIsland[i] = changesUVIslandParam;
break;
}
}
}
};
void PlanarlyProjectVertex(const FVector3f& unfoldedPosition, FVector4f& projectedPosition,
const FProjector& projector, const FVector3f& projectorPosition, const FVector3f& projectorDirection, const FVector3f& s, const FVector3f& u)
{
float x = FVector3f::DotProduct( unfoldedPosition - projectorPosition, s ) / projector.scale[0] + 0.5f;
float y = FVector3f::DotProduct( unfoldedPosition - projectorPosition, u ) / projector.scale[1] + 0.5f;
y = 1.0f - y;
float z = FVector3f::DotProduct( unfoldedPosition - projectorPosition, projectorDirection ) / projector.scale[2];
bool inside = x>=0.0f && x<=1.0f && y>=0.0f && y<=1.0 && z>=0.0f && z<=1.0f;
projectedPosition[0] = x;
projectedPosition[1] = y;
projectedPosition[2] = z;
projectedPosition[3] = inside ? 1.0f : 0.0f;
}
FVector2f ChangeBase2D(const FVector2f& origPosition, const FVector2f& newOrigin, const FVector2f& newBaseX, const FVector2f& newBaseY)
{
float x = FVector2f::DotProduct(origPosition - newOrigin, newBaseX) / newBaseX.SquaredLength() + 0.5f;
float y = FVector2f::DotProduct(origPosition - newOrigin, newBaseY) / newBaseY.SquaredLength() + 0.5f;
//y = 1.0f - y;
return FVector2f(x, y);
}
// Compute barycentric coordinates (u, v, w) for
// point p with respect to triangle (a, b, c)
void GetBarycentricCoords(FVector3f p, FVector3f a, FVector3f b, FVector3f c, float &u, float &v, float &w)
{
FVector3f v0 = b - a, v1 = c - a, v2 = p - a;
float d00 = FVector3f::DotProduct(v0, v0);
float d01 = FVector3f::DotProduct(v0, v1);
float d11 = FVector3f::DotProduct(v1, v1);
float d20 = FVector3f::DotProduct(v2, v0);
float d21 = FVector3f::DotProduct(v2, v1);
float denom = d00 * d11 - d01 * d01;
v = (d11 * d20 - d01 * d21) / denom;
w = (d00 * d21 - d01 * d20) / denom;
u = 1.0f - v - w;
}
void GetBarycentricCoords(FVector2f p, FVector2f a, FVector2f b, FVector2f c, float &u, float &v, float &w)
{
FVector2f v0 = b - a, v1 = c - a, v2 = p - a;
float den = v0.X * v1.Y - v1.X * v0.Y;
#ifdef DEBUG_PROJECTION
assert(den != 0.f);
#endif
v = (v2.X * v1.Y - v1.X * v2.Y) / den;
w = (v0.X * v2.Y - v2.X * v0.Y) / den;
u = 1.0f - v - w;
}
float getTriangleArea(FVector2f& a, FVector2f& b, FVector2f& c)
{
float area = a.X * (b.Y - c.Y) + b.X * (c.Y - a.Y) + c.X * (a.Y - b.Y);
return area / 2.f;
}
float getTriangleRatio(const FVector2f& a, const FVector2f& b, const FVector2f& c)
{
float lenSide1 = (b - a).Length();
float lenSide2 = (c - a).Length();
float lenSide3 = (b - c).Length();
float maxLen = FMath::Max3(lenSide1, lenSide2, lenSide3);
float minLen = FMath::Min3(lenSide1, lenSide2, lenSide3);
return maxLen / minLen;
}
struct NeighborFace
{
int32 neighborFace;
int32 newVertex;
int32 previousFace;
int32 numUVIslandChanges = 0;
int32 step;
bool changesUVIsland;
friend bool operator <(const NeighborFace& a, const NeighborFace& b)
{
//if (a.numUVIslandChanges == b.numUVIslandChanges)
//{
return a.step < b.step;
//}
//return a.numUVIslandChanges > b.numUVIslandChanges;
}
};
void getEdgeHorizontalLength( int32 edgeVert0, int32 edgeVert1, int32 opposedVert,
const FOptimizedVertex* pVertices,
float &out_uvSpaceLen, float &out_objSpaceLen,
float& out_midEdgePointFraction)
{
const int32 oldVertices[2] = { edgeVert0, edgeVert1 };
const FVector2f& edge0_oldUVSpace = pVertices[oldVertices[0]].Uv;
const FVector2f& edge1_oldUVSpace = pVertices[oldVertices[1]].Uv;
const FVector2f& opposedVert_oldUVSpace = pVertices[opposedVert].Uv;
FVector2f edgeVector_oldUVSpace = edge1_oldUVSpace - edge0_oldUVSpace;
FVector2f sideVector_oldUVSpace = opposedVert_oldUVSpace - edge0_oldUVSpace;
float edgeVector_oldUVSpaceLen = edgeVector_oldUVSpace.Length();
float dotEdgeSideVectors_oldUVSpace = FVector2f::DotProduct(edgeVector_oldUVSpace, sideVector_oldUVSpace);
float midEdgePointFraction_oldUVSpace = (dotEdgeSideVectors_oldUVSpace / powf(edgeVector_oldUVSpaceLen, 2));
FVector2f edgeVectorProj_oldUVSpace = edgeVector_oldUVSpace * midEdgePointFraction_oldUVSpace;
FVector2f midEdgePoint_oldUVSpace = edge0_oldUVSpace + edgeVectorProj_oldUVSpace;
FVector2f perpEdgeVector_oldUVSpace = opposedVert_oldUVSpace - midEdgePoint_oldUVSpace;
#ifdef DEBUG_PROJECTION
assert(fabs(dot(perpEdgeVector_oldUVSpace, edgeVector_oldUVSpace)) < 0.1f);
#endif
float perpEdgeVector_oldUVSpace_Len = perpEdgeVector_oldUVSpace.Length();
out_uvSpaceLen = perpEdgeVector_oldUVSpace_Len;
out_midEdgePointFraction = midEdgePointFraction_oldUVSpace;
// Do the same in object space to be able to extract the scale of the original uv space
const FVector3f& edge0_objSpace = pVertices[oldVertices[0]].Position;
const FVector3f& edge1_objSpace = pVertices[oldVertices[1]].Position;
const FVector3f& opposedVert_objSpace = pVertices[opposedVert].Position; // FIXME
FVector3f edgeVector_objSpace = edge1_objSpace - edge0_objSpace;
FVector3f sideVector_objSpace = opposedVert_objSpace - edge0_objSpace;
float edgeVector_objSpaceLen = edgeVector_objSpace.Length();
float dotEdgeSideVectors_objSpace = FVector3f::DotProduct(edgeVector_objSpace, sideVector_objSpace);
float midEdgePointFraction_objSpace = (dotEdgeSideVectors_objSpace / powf(edgeVector_objSpaceLen, 2));
FVector3f edgeVectorProj_objSpace = edgeVector_objSpace * midEdgePointFraction_objSpace;
FVector3f midEdgePoint_objSpace = edge0_objSpace + edgeVectorProj_objSpace;
FVector3f perpEdgeVector_objSpace = opposedVert_objSpace - midEdgePoint_objSpace;
#ifdef DEBUG_PROJECTION
assert(fabs(dot(perpEdgeVector_objSpace, edgeVector_objSpace)) < 0.1f);
#endif
float perpEdgeVector_objSpace_Len = perpEdgeVector_objSpace.Length();
out_objSpaceLen = perpEdgeVector_objSpace_Len;
}
bool testPointsAreInOppositeSidesOfEdge( const FVector2f& pointA, const FVector2f& pointB,
const FVector2f& edge0, const FVector2f& edge1 )
{
FVector2f edge = edge1 - edge0;
FVector2f perp_edge = FVector2f(-edge.Y, edge.X);
FVector2f AVertexVector = pointA - edge0;
FVector2f BVertexVector = pointB - edge0;
float dotAVertexVector = FVector2f::DotProduct(AVertexVector, perp_edge);
float dotBVertexVector = FVector2f::DotProduct(BVertexVector, perp_edge);
return dotAVertexVector * dotBVertexVector < 0.f;
}
//-------------------------------------------------------------------------------------------------
#pragma pack(push,1)
struct PROJECTED_VERTEX
{
float pos0 = 0, pos1 = 0, pos2 = 0;
uint32 mask3 = 0;
inline FVector2f xy() const { return FVector2f(pos0,pos1); }
};
#pragma pack(pop)
static_assert( sizeof(PROJECTED_VERTEX)==16, "Unexpected struct size" );
//-------------------------------------------------------------------------------------------------
void MeshProject_Optimised_Planar(const FOptimizedVertex* pVertices, int32 vertexCount,
const uint32* pIndices, int32 faceCount,
const FVector3f& projectorPosition, const FVector3f& projectorDirection,
const FVector3f& projectorSide, const FVector3f& projectorUp,
const FVector3f& projectorScale,
FOptimizedVertex* pResultVertices, int32& currentVertex,
uint32* pResultIndices, int32& currentIndex)
{
MUTABLE_CPUPROFILER_SCOPE(MeshProject_Optimised_Planar)
TArray<int32> oldToNewVertex;
oldToNewVertex.Init(-1,vertexCount);
TArray<PROJECTED_VERTEX> projectedPositions;
projectedPositions.SetNumZeroed(vertexCount);
for ( int32 v=0; v<vertexCount; ++v )
{
float x = FVector3f::DotProduct(pVertices[v].Position - projectorPosition, projectorSide) / projectorScale[0] + 0.5f;
float y = FVector3f::DotProduct(pVertices[v].Position - projectorPosition, projectorUp) / projectorScale[1] + 0.5f;
y = 1.0f-y;
float z = FVector3f::DotProduct(pVertices[v].Position - projectorPosition, projectorDirection) / projectorScale[2];
// Plane mask with bits for each plane discarding the vertex
uint32 planeMask =
((x<0.0f)<<0) |
((x>1.0f)<<1) |
((y<0.0f)<<2) |
((y>1.0f)<<3) |
((z<0.0f)<<4) |
((z>1.0f)<<5);
projectedPositions[v].pos0 = x;
projectedPositions[v].pos1 = y;
projectedPositions[v].pos2 = z;
projectedPositions[v].mask3 = planeMask;
}
// Iterate the faces
for ( int32 f=0; f<faceCount; ++f )
{
int32 i0 = pIndices[f*3+0];
int32 i1 = pIndices[f*3+1];
int32 i2 = pIndices[f*3+2];
// Approximate test: discard the triangle if any of the 6 planes entirely discards all the vertices.
// This will let some triangles through that could be discarded with a precise test.
bool discarded = (
projectedPositions[i0].mask3 &
projectedPositions[i1].mask3 &
projectedPositions[i2].mask3 )
!=
0;
if ( !discarded )
{
// This face is required.
for (int32 v=0;v<3;++v)
{
uint32 i = pIndices[f*3+v];
if (oldToNewVertex[i]<0)
{
pResultVertices[currentVertex] = pVertices[i];
pResultVertices[currentVertex].Position[0] = projectedPositions[i].pos0;
pResultVertices[currentVertex].Position[1] = projectedPositions[i].pos1;
pResultVertices[currentVertex].Position[2] = projectedPositions[i].pos2;
// Normal is actually the fade factor
float angleCos = FVector3f::DotProduct(pVertices[i].Normal, projectorDirection * -1.0f);
pResultVertices[currentVertex].Normal[0] = angleCos;
pResultVertices[currentVertex].Normal[1] = angleCos;
pResultVertices[currentVertex].Normal[2] = angleCos;
oldToNewVertex[i] = currentVertex++;
}
pResultIndices[currentIndex++] = oldToNewVertex[i];
}
}
}
}
//-------------------------------------------------------------------------------------------------
void MeshProject_Optimised_Cylindrical(const FOptimizedVertex* pVertices, int32 vertexCount,
const uint32* pIndices, int32 faceCount,
const FVector3f& projectorPosition, const FVector3f& projectorDirection,
const FVector3f& projectorSide, const FVector3f& projectorUp,
const FVector3f& projectorScale,
FOptimizedVertex* pResultVertices, int32& currentVertex,
uint32* pResultIndices, int32& currentIndex)
{
MUTABLE_CPUPROFILER_SCOPE(MeshProject_Optimised_Cylindrical)
TArray<int32> oldToNewVertex;
oldToNewVertex.Init( -1, vertexCount);
TArray<PROJECTED_VERTEX> projectedPositions;
projectedPositions.SetNumZeroed(vertexCount);
// TODO: support for non uniform scale?
float radius = projectorScale[1];
float height = projectorScale[0];
FMatrix44f WorldToCylinder(projectorDirection, projectorSide, projectorUp,FVector3f(0,0,0));
for ( int32 v=0; v<vertexCount; ++v )
{
// Cylinder is along the X axis
// Project
FVector3f RelPos = pVertices[v].Position - projectorPosition;
FVector3f VertexPos_Cylinder = WorldToCylinder.InverseTransformPosition(RelPos);
// This final projection needs to be done per pixel
float x = VertexPos_Cylinder.X / height;
float r2 = VertexPos_Cylinder.Y * VertexPos_Cylinder.Y
+ VertexPos_Cylinder.Z * VertexPos_Cylinder.Z;
projectedPositions[v].pos0 = x;
projectedPositions[v].pos1 = VertexPos_Cylinder.Y / radius;
projectedPositions[v].pos2 = VertexPos_Cylinder.Z / radius;
uint32 planeMask =
((x<0.0f)<<0) |
((x>1.0f)<<1) |
((r2>=(radius*radius))<<2);
projectedPositions[v].mask3 = planeMask;
}
// Iterate the faces
for ( int32 f=0; f<faceCount; ++f )
{
int32 i0 = pIndices[f*3+0];
int32 i1 = pIndices[f*3+1];
int32 i2 = pIndices[f*3+2];
// Approximate test: discard the triangle if any of the 3 "planes" (top, bottom and radius)
// entirely discards all the vertices.
// This will let some triangles through that could be discarded with a precise test.
// Also, some big triangles can be wrongly discarded by the radius test, since it is not
// really a plane.
bool discarded = (
projectedPositions[i0].mask3 &
projectedPositions[i1].mask3 &
projectedPositions[i2].mask3 )
!=
0;
if ( !discarded )
{
// This face is required.
for (int32 v=0;v<3;++v)
{
uint32 i = pIndices[f*3+v];
if (oldToNewVertex[i]<0)
{
pResultVertices[currentVertex] = pVertices[i];
pResultVertices[currentVertex].Position[0] = projectedPositions[i].pos0;
pResultVertices[currentVertex].Position[1] = projectedPositions[i].pos1;
pResultVertices[currentVertex].Position[2] = projectedPositions[i].pos2;
// Normal is actually the fade factor
//vec3 vertexCylinderDirection =
float angleCos = 1.0f; //dot( pVertices[i].Normal, vertexCylinderDirection * -1.0f );
pResultVertices[currentVertex].Normal[0] = angleCos;
pResultVertices[currentVertex].Normal[1] = angleCos;
pResultVertices[currentVertex].Normal[2] = angleCos;
oldToNewVertex[i] = currentVertex++;
}
pResultIndices[currentIndex++] = oldToNewVertex[i];
}
}
}
}
//-------------------------------------------------------------------------------------------------
void MeshProject_Optimised_Wrapping(const FMesh* pMesh,
const FVector3f& projectorPosition, const FVector3f& projectorDirection,
const FVector3f& projectorSide, const FVector3f& projectorUp,
const FVector3f& projectorScale,
FOptimizedVertex* pResultVertices, uint64* pResultLayoutBlockIds, int32& currentVertex,
uint32* pResultIndices, int32& currentIndex)
{
MUTABLE_CPUPROFILER_SCOPE(MeshProject_Optimised_Wrapping)
// Get the vertices
int32 vertexCount = pMesh->GetVertexCount();
check(pMesh->GetVertexBuffers().GetElementSize(0) == sizeof(FOptimizedVertex));
check(pMesh->GetVertexBuffers().Buffers.Num() == 2);
const FOptimizedVertex* pVertices = reinterpret_cast<const FOptimizedVertex*>(pMesh->GetVertexBuffers().GetBufferData(0));
EMeshBufferFormat LayoutBlockType = pMesh->VertexBuffers.Buffers[1].Channels[0].Format;
// Get the indices
check(pMesh->GetIndexBuffers().GetElementSize(0) == 4);
const uint32* pIndices = reinterpret_cast<const uint32*>(pMesh->GetIndexBuffers().GetBufferData(0));
int32 faceCount = pMesh->GetFaceCount();
TArray<PROJECTED_VERTEX> projectedPositions;
projectedPositions.SetNum(vertexCount);
// Iterate the faces and trace a ray to find the origin face of the projection
const float maxDist = 100000.f; // TODO: This should be proportional to the mesh bounding box size.
float min_t = maxDist;
float rayLength = maxDist;
int32 intersectedFace = -1;
TSet<int32> processedVertices;
FVector3f projectionPlaneNormal;
FVector3f out_intersection;
TArray<AdjacentFaces> faceConnectivity;
faceConnectivity.SetNum(faceCount);
TSet<int32> processedFaces;
processedFaces.Reserve(faceCount/4);
TSet<int32> discardedWrapAroundFaces;
discardedWrapAroundFaces.Reserve(faceCount/16);
TArray<int32> faceStep;
faceStep.SetNum(faceCount);
// Map vertices to the one they are collapsed to because they are very similar, if they aren't collapsed then they are mapped to themselves
TArray<int32> collapsedVertexMap;
TArray<FVector3f> vertices;
TMultiMap<int32, int32> collapsedVertsMap; // Maps a collapsed vertex to all the vertices that collapse to it
MeshCreateCollapsedVertexMap(pMesh, collapsedVertexMap, collapsedVertsMap, vertices);
// Used to speed up connectivity building
TMultiMap<int32, int32> vertToFacesMap;
vertToFacesMap.Reserve(vertexCount);
for (int32 f = 0; f < faceCount; ++f)
{
int32 i0 = pIndices[f * 3 + 0];
int32 i1 = pIndices[f * 3 + 1];
int32 i2 = pIndices[f * 3 + 2];
vertToFacesMap.Add(collapsedVertexMap[i0], f);
vertToFacesMap.Add(collapsedVertexMap[i1], f);
vertToFacesMap.Add(collapsedVertexMap[i2], f);
}
FRay3f Ray(projectorPosition, projectorDirection, false);
UE::Geometry::FIntrRay3Triangle3f Intersector(Ray, UE::Geometry::FTriangle3f());
// Trace a ray in the projection direction to find the face that will be projected planarly and be the root of the unfolding
// Also build face connectivity information
for (int32 f = 0; f < faceCount; ++f)
{
int32 i0 = pIndices[f * 3 + 0];
int32 i1 = pIndices[f * 3 + 1];
int32 i2 = pIndices[f * 3 + 2];
FVector3f rayStart = projectorPosition;
FVector3f rayEnd = projectorPosition + projectorDirection * maxDist;
Intersector.Triangle = UE::Geometry::FTriangle3f(pVertices[i0].Position, pVertices[i1].Position, pVertices[i2].Position);
rayLength = (rayEnd - rayStart).Length();
bool bIntersects = Intersector.Find();
float t = Intersector.RayParameter;
FVector3f aux_out_intersection = Ray.PointAt(Intersector.RayParameter);
if (bIntersects && t < min_t)
{
intersectedFace = f;
min_t = t;
out_intersection = aux_out_intersection;
FVector3f v0 = pVertices[i0].Position;
FVector3f v1 = pVertices[i1].Position;
FVector3f v2 = pVertices[i2].Position;
projectionPlaneNormal = FVector3f::CrossProduct(v1 - v0, v2 - v0).GetSafeNormal();
}
// Face connectivity info
for (int32 i = 0; i < 3; ++i)
{
int32 v = collapsedVertexMap[pIndices[f * 3 + i]];
//int32 v = pIndices[f * 3 + i];
TArray<int32,TInlineAllocator<32>> FoundValues;
vertToFacesMap.MultiFind(v, FoundValues);
for (int32 f2 : FoundValues )
{
if (f != f2 && f2 >= 0)
{
int32 commonVertices = 0;
int32 commonVerticesDifferentIsland = 0;
bool commonMask[3] = { false, false, false };
for (int32 ii = 0; ii < 3; ++ii)
{
int32 f_vertex_orig = pIndices[f * 3 + ii];
int32 f_vertex = collapsedVertexMap[f_vertex_orig];
//int32 f_vertex = pIndices[f * 3 + ii];
for (int32 j = 0; j < 3; ++j)
{
int32 f2_vertex_orig = pIndices[f2 * 3 + j];
int32 f2_vertex = collapsedVertexMap[f2_vertex_orig];
//int32 f2_vertex = pIndices[f2 * 3 + j];
if (f_vertex != -1 && f_vertex == f2_vertex)
{
commonVertices++;
commonMask[j] = true;
if (f_vertex_orig != f2_vertex_orig)
{
commonVerticesDifferentIsland++;
}
}
}
}
#ifdef DEBUG_PROJECTION
assert(commonVerticesDifferentIsland <= commonVertices);
#endif
if (commonVertices == 2)
{
int32 newVertex = -1;
for (int32 j = 0; j < 3; ++j)
{
if (!commonMask[j])
{
newVertex = collapsedVertexMap[pIndices[f2 * 3 + j]];
//newVertex = pIndices[f2 * 3 + j];
break;
}
}
#ifdef DEBUG_PROJECTION
assert(newVertex >= 0);
#endif
faceConnectivity[f].addConnectedFace(f2, newVertex, commonVerticesDifferentIsland == 2);
}
}
}
}
}
// New projector located perpendicularly up from the hit face
FProjector projector2;
projector2.direction[0] = projectionPlaneNormal[0];
projector2.direction[1] = projectionPlaneNormal[1];
projector2.direction[2] = projectionPlaneNormal[2];
FVector3f auxPosition = out_intersection - projectionPlaneNormal * rayLength * min_t;
//FVector3f auxPosition = FVector3f( projector.position[0], projector.position[1], projector.position[2] );
projector2.position[0] = auxPosition[0];
projector2.position[1] = auxPosition[1];
projector2.position[2] = auxPosition[2];
FVector3f auxUp = projectorUp;
float test = fabs(FVector3f::DotProduct(auxUp, projectionPlaneNormal));
if (test < 0.9f)
{
FVector3f auxSide = FVector3f::CrossProduct(projectionPlaneNormal, auxUp).GetSafeNormal();
auxUp = FVector3f::CrossProduct(auxSide, projectionPlaneNormal);
}
else
{
auxUp = FVector3f::CrossProduct(projectionPlaneNormal, projectorSide);
}
projector2.up[0] = auxUp[0];
projector2.up[1] = auxUp[1];
projector2.up[2] = auxUp[2];
projector2.scale[0] = projectorScale[0];
projector2.scale[1] = projectorScale[1];
projector2.scale[2] = projectorScale[2];
FVector3f projectorDirection2, s2, u2;
FVector3f projectorPosition2 = projector2.position;
projector2.GetDirectionSideUp( projectorDirection2, s2, u2 );
float maxDistSquared = powf(projector2.scale[0], 2.f) + powf(projector2.scale[1], 2.f);
// Do a BFS walk of the mesh, unfolding a face at each step
if (intersectedFace >= 0)
{
TArray<NeighborFace> pendingFaces; // Queue of pending face + new vertex
pendingFaces.Reserve(faceCount/64);
// \TODO: Bool array to speed up?
TSet<int32> pendingFacesUnique; // Used to quickly check uniqueness in the pendingFaces queue
pendingFacesUnique.Reserve(faceCount / 64);
//FVector3f hitFaceProjectedNormal;
bool hitFaceHasPositiveArea = false;
NeighborFace neighborFace;
neighborFace.neighborFace = intersectedFace;
neighborFace.newVertex = -1; // -1 because all the vertices of the face are new
neighborFace.previousFace = -1;
neighborFace.numUVIslandChanges = 0;
neighborFace.step = 0;
neighborFace.changesUVIsland = false;
pendingFaces.HeapPush(neighborFace);
pendingFacesUnique.Add(intersectedFace);
int32 step = 0;
float totalUVAreaCovered = 0.f;
TArray<int32> oldVertices;
oldVertices.Reserve(3);
while (!pendingFaces.IsEmpty())
{
NeighborFace currentFaceStruct;
pendingFaces.HeapPop(currentFaceStruct);
int32 currentFace = currentFaceStruct.neighborFace;
#ifdef DEBUG_PROJECTION
int32 newVertexFromQueue = currentFaceStruct.newVertex;
#endif
pendingFacesUnique.Remove(currentFace);
processedFaces.Add(currentFace);
faceStep[currentFace] = step;
float currentTriangleArea = -2.f;
// Process the face's vertices
if (currentFace == intersectedFace)
{
#ifdef DEBUG_PROJECTION
assert(newVertexFromQueue == -1);
#endif
FVector3f outIntersectionBaricentric;
int32 i0 = pIndices[currentFace * 3 + 0];
int32 i1 = pIndices[currentFace * 3 + 1];
int32 i2 = pIndices[currentFace * 3 + 2];
FVector3f v3_0 = pVertices[i0].Position;
FVector3f v3_1 = pVertices[i1].Position;
FVector3f v3_2 = pVertices[i2].Position;
GetBarycentricCoords(out_intersection, v3_0, v3_1, v3_2, outIntersectionBaricentric[0], outIntersectionBaricentric[1], outIntersectionBaricentric[2]);
FVector2f outIntersectionUV = pVertices[i0].Uv * outIntersectionBaricentric[0] + pVertices[i1].Uv * outIntersectionBaricentric[1] + pVertices[i2].Uv * outIntersectionBaricentric[2];
FVector4f proj4D_v0, proj4D_v1, proj4D_v2;
PlanarlyProjectVertex(pVertices[i0].Position, proj4D_v0, projector2, projectorPosition2, projectorDirection2, s2, u2);
PlanarlyProjectVertex(pVertices[i1].Position, proj4D_v1, projector2, projectorPosition2, projectorDirection2, s2, u2);
PlanarlyProjectVertex(pVertices[i2].Position, proj4D_v2, projector2, projectorPosition2, projectorDirection2, s2, u2);
FVector2f proj_v0 = FVector2f(proj4D_v0[0], proj4D_v0[1]);
FVector2f proj_v1 = FVector2f(proj4D_v1[0], proj4D_v1[1]);
FVector2f proj_v2 = FVector2f(proj4D_v2[0], proj4D_v2[1]);
float proj_TriangleArea = getTriangleArea(proj_v0, proj_v1, proj_v2);
FVector3f BaricentricBaseU;
FVector3f BaricentricBaseV;
FVector3f BaricentricOrigin;
GetBarycentricCoords(FVector2f(1.f, 0.f), proj_v0, proj_v1, proj_v2, BaricentricBaseU[0], BaricentricBaseU[1], BaricentricBaseU[2]);
GetBarycentricCoords(FVector2f(0.f, 1.f), proj_v0, proj_v1, proj_v2, BaricentricBaseV[0], BaricentricBaseV[1], BaricentricBaseV[2]);
GetBarycentricCoords(FVector2f(0.f, 0.f), proj_v0, proj_v1, proj_v2, BaricentricOrigin[0], BaricentricOrigin[1], BaricentricOrigin[2]);
FVector2f OrigUVs_BaseU_EndPoint = pVertices[i0].Uv * BaricentricBaseU[0] + pVertices[i1].Uv * BaricentricBaseU[1] + pVertices[i2].Uv * BaricentricBaseU[2];
FVector2f OrigUVs_BaseV_EndPoint = pVertices[i0].Uv * BaricentricBaseV[0] + pVertices[i1].Uv * BaricentricBaseV[1] + pVertices[i2].Uv * BaricentricBaseV[2];
FVector2f OrigUVs_Origin = pVertices[i0].Uv * BaricentricOrigin[0] + pVertices[i1].Uv * BaricentricOrigin[1] + pVertices[i2].Uv * BaricentricOrigin[2];
FVector2f OrigUVs_BaseU = OrigUVs_BaseU_EndPoint - OrigUVs_Origin;
FVector2f OrigUVs_BaseV_Aux = OrigUVs_BaseV_EndPoint - OrigUVs_Origin;
OrigUVs_BaseU = OrigUVs_BaseU.GetSafeNormal();
OrigUVs_BaseV_Aux = OrigUVs_BaseV_Aux.GetSafeNormal();
// Generate perp vector from OrigUVs_BaseU by flipping coords and one sign. Using OrigUVs_BaseV directly sometimes doesn't give an orthogonal basis
FVector2f OrigUVs_BaseV = FVector2f(copysign(OrigUVs_BaseU.Y, OrigUVs_BaseV_Aux.X), copysign(OrigUVs_BaseU.X, OrigUVs_BaseV_Aux.Y));
#ifdef DEBUG_PROJECTION
assert(fabs(dot(OrigUVs_BaseU, OrigUVs_BaseV)) < 0.3f);
#endif
OrigUVs_Origin = outIntersectionUV;
GetBarycentricCoords(outIntersectionUV, pVertices[i0].Uv, pVertices[i1].Uv, pVertices[i2].Uv, outIntersectionBaricentric[0], outIntersectionBaricentric[1], outIntersectionBaricentric[2]);
for (int32 i = 0; i < 3; ++i)
{
int32 v = pIndices[currentFace * 3 + i];
#ifdef DEBUG_PROJECTION
assert(v >= 0 && v < vertexCount);
#endif
int32 collapsedVert = collapsedVertexMap[v];
processedVertices.Add(collapsedVert);
//PlanarlyProjectVertex(pVertices[collapsedVert].pos, projectedPositions[collapsedVert], projector2, projectorPosition2, projectorDirection2, s2, u2);
FVector2f projectedVertex = ChangeBase2D(pVertices[v].Uv, OrigUVs_Origin, OrigUVs_BaseU, OrigUVs_BaseV);
projectedPositions[collapsedVert].pos0 = projectedVertex[0];
projectedPositions[collapsedVert].pos1 = projectedVertex[1];
projectedPositions[collapsedVert].pos2 = 0.f;
projectedPositions[collapsedVert].mask3 = 1;
}
FVector2f v0 = projectedPositions[collapsedVertexMap[pIndices[currentFace * 3 + 0]]].xy();
FVector2f v1 = projectedPositions[collapsedVertexMap[pIndices[currentFace * 3 + 1]]].xy();
FVector2f v2 = projectedPositions[collapsedVertexMap[pIndices[currentFace * 3 + 2]]].xy();
currentTriangleArea = getTriangleArea(v0, v1, v2);
float triangleAreaFactor = sqrt(fabs(proj_TriangleArea) / fabs(currentTriangleArea));
FVector2f origin = v0 * outIntersectionBaricentric[0] + v1 * outIntersectionBaricentric[1] + v2 * outIntersectionBaricentric[2];
#ifdef DEBUG_PROJECTION
assert(length(origin - FVector2f(0.5f, 0.5f)) < 0.001f);
#endif
//hitFaceProjectedNormal = (cross<float>(v1 - v0, v2 - v0));
hitFaceHasPositiveArea = currentTriangleArea >= 0.f;
for (int32 i = 0; i < 3; ++i)
{
int32 v = pIndices[currentFace * 3 + i];
int32 collapsedVert = collapsedVertexMap[v];
projectedPositions[collapsedVert].pos0 = ((projectedPositions[collapsedVert].pos0 - 0.5f) * triangleAreaFactor) + 0.5f;
projectedPositions[collapsedVert].pos1 = ((projectedPositions[collapsedVert].pos1 - 0.5f) * triangleAreaFactor) + 0.5f;
projectedPositions[collapsedVert].pos2 = 0.f;
projectedPositions[collapsedVert].mask3 = projectedPositions[collapsedVert].pos0 >= 0.0f && projectedPositions[collapsedVert].pos0 <= 1.0f &&
projectedPositions[collapsedVert].pos1 >= 0.0f && projectedPositions[collapsedVert].pos1 <= 1.0f;
// Copy the new info to all the vertices that collapse to the same vertex
TArray<int32> FoundValues;
collapsedVertsMap.MultiFind(collapsedVert,FoundValues);
for (int32 otherVert:FoundValues)
{
processedVertices.Add(otherVert);
projectedPositions[otherVert] = projectedPositions[collapsedVert];
}
}
v0 = projectedPositions[collapsedVertexMap[pIndices[currentFace * 3 + 0]]].xy();
v1 = projectedPositions[collapsedVertexMap[pIndices[currentFace * 3 + 1]]].xy();
v2 = projectedPositions[collapsedVertexMap[pIndices[currentFace * 3 + 2]]].xy();
currentTriangleArea = getTriangleArea(v0, v1, v2);
#ifdef DEBUG_PROJECTION
assert(fabs(proj_TriangleArea - currentTriangleArea) / proj_TriangleArea < 0.1f);
#endif
origin = v0 * outIntersectionBaricentric[0] + v1 * outIntersectionBaricentric[1] + v2 * outIntersectionBaricentric[2];
#ifdef DEBUG_PROJECTION
assert(length(origin - FVector2f(0.5f, 0.5f)) < 0.001f);
#endif
}
else
{
// Unwrap the rest of the faces
#ifdef DEBUG_PROJECTION
assert(newVertexFromQueue >= 0);
#endif
int32 newVertex = -1;
//int32 oldVertices[2] = { -1, -1 };
oldVertices.Empty();
bool reverseOrder = false;
for (int32 i = 0; i < 3; ++i)
{
int32 v = pIndices[currentFace * 3 + i];
if (!processedVertices.Contains(collapsedVertexMap[v]))
{
newVertex = v;
if (i == 1)
{
reverseOrder = true;
}
}
else
{
//int32 index = oldVertices[0] == -1 ? 0 : 1;
//oldVertices[index] = v;
//oldVertices.push_back(collapsedVertexMap[v]);
oldVertices.Add(v);
}
}
if (reverseOrder && oldVertices.Num() == 2)
{
int32 aux = oldVertices[0];
oldVertices[0] = oldVertices[1];
oldVertices[1] = aux;
}
if (newVertex >= 0)
{
#ifdef DEBUG_PROJECTION
assert(newVertex >= 0);
//assert(collapsedVertexMap[newVertex] == newVertexFromQueue);
assert(oldVertices[0] >= 0 && oldVertices[1] >= 0);
assert(oldVertices.Num() == 2);
assert(newVertex < vertexCount && oldVertices[0] < vertexCount && oldVertices[1] < vertexCount);
#endif
int32 previousFace = currentFaceStruct.previousFace;
#ifdef DEBUG_PROJECTION
assert(previousFace >= 0);
assert(processedFaces.count(previousFace) == 1);
#endif
// Previous face indices
int32 pi0 = pIndices[previousFace * 3 + 0];
int32 pi1 = pIndices[previousFace * 3 + 1];
int32 pi2 = pIndices[previousFace * 3 + 2];
// Previous face uv coords
FVector2f pv0;
FVector2f pv1;
FVector2f pv2;
// Proj vertices from previous triangle
FVector2f pv0_proj;
FVector2f pv1_proj;
FVector2f pv2_proj;
int32 oldVertices_previousFace[2] = { -1, -1 };
int32 oldVertex = -1;
for (int32 i = 0; i < 3; ++i)
{
int32 v = pIndices[previousFace * 3 + i];
int32 collapsed_v = collapsedVertexMap[v];
if (collapsed_v == collapsedVertexMap[oldVertices[0]])
{
oldVertices_previousFace[0] = v;
}
else if (collapsed_v == collapsedVertexMap[oldVertices[1]])
{
oldVertices_previousFace[1] = v;
}
else
{
oldVertex = v;
}
}
if (currentFaceStruct.changesUVIsland)
{
// It's crossing a uv island border, so the previous uvs need to be converted to the new islands uv space
#ifdef DEBUG_PROJECTION
assert(oldVertex >= 0 && oldVertices_previousFace[0] >= 0 && oldVertices_previousFace[1] >= 0);
assert(oldVertex != newVertex && oldVertices_previousFace[0] != oldVertices[0] && oldVertices_previousFace[1] != oldVertices[1]);
assert(collapsedVertexMap[oldVertices_previousFace[0]] == collapsedVertexMap[oldVertices[0]]);
assert(collapsedVertexMap[oldVertices_previousFace[1]] == collapsedVertexMap[oldVertices[1]]);
#endif
// Compute the horizontal lengths in the previous island old (original) uv space, and in obj space
float previousFace_uvSpaceLen, previousFace_objSpaceLen, midEdgePointFraction_previousFace;
getEdgeHorizontalLength(oldVertices_previousFace[0], oldVertices_previousFace[1], oldVertex, pVertices, previousFace_uvSpaceLen, previousFace_objSpaceLen, midEdgePointFraction_previousFace);
float currentFace_uvSpaceLen, currentFace_objSpaceLen, midEdgePointFraction_currentFace;
getEdgeHorizontalLength(oldVertices[0], oldVertices[1], newVertex, pVertices, currentFace_uvSpaceLen, currentFace_objSpaceLen, midEdgePointFraction_currentFace);
float objSpaceToCurrentUVSpaceConversion = currentFace_uvSpaceLen / currentFace_objSpaceLen;
float previousFaceWidthInCurrentUVspace = previousFace_objSpaceLen * objSpaceToCurrentUVSpaceConversion;
const FVector2f& edge0_currentFace_oldUVSpace = pVertices[oldVertices[0]].Uv;
const FVector2f& edge1_currentFace_oldUVSpace = pVertices[oldVertices[1]].Uv;
const FVector2f& newVertex_currentFace_oldUVSpace = pVertices[newVertex].Uv;
FVector2f edge_currentFace_oldUVSpace = edge1_currentFace_oldUVSpace - edge0_currentFace_oldUVSpace;
FVector2f midpoint_currentFace_oldUVSpace = edge0_currentFace_oldUVSpace + edge_currentFace_oldUVSpace * midEdgePointFraction_currentFace;
FVector2f edgePerpVectorNorm = (midpoint_currentFace_oldUVSpace - newVertex_currentFace_oldUVSpace).GetSafeNormal();
FVector2f test_edge_currentFace_oldUVSpaceNorm = edge_currentFace_oldUVSpace.GetSafeNormal();
(void)test_edge_currentFace_oldUVSpaceNorm;
#ifdef DEBUG_PROJECTION
FVector2f sideVector_oldUVSpace = newVertex_currentFace_oldUVSpace - edge0_currentFace_oldUVSpace;
float edgeVector_oldUVSpaceLen = length(edge_currentFace_oldUVSpace);
float dotEdgeSideVectors_oldUVSpace = dot(edge_currentFace_oldUVSpace, sideVector_oldUVSpace);
float midEdgePointFraction_oldUVSpace = (dotEdgeSideVectors_oldUVSpace / powf(edgeVector_oldUVSpaceLen, 2));
assert(fabs(midEdgePointFraction_oldUVSpace - midEdgePointFraction_currentFace) < 0.01f);
assert(fabs(dot(edgePerpVectorNorm, test_edge_currentFace_oldUVSpaceNorm)) < 0.1f);
#endif
FVector2f midpoint_previousFace_oldUVSpace = edge0_currentFace_oldUVSpace + edge_currentFace_oldUVSpace * midEdgePointFraction_previousFace;
FVector2f oldVertex_currentFace_oldUVSpace = midpoint_previousFace_oldUVSpace + edgePerpVectorNorm * previousFaceWidthInCurrentUVspace;
pv0 = edge0_currentFace_oldUVSpace;
pv1 = edge1_currentFace_oldUVSpace;
pv2 = oldVertex_currentFace_oldUVSpace;
pv0_proj = projectedPositions[collapsedVertexMap[oldVertices[0]]].xy();
pv1_proj = projectedPositions[collapsedVertexMap[oldVertices[1]]].xy();
pv2_proj = projectedPositions[collapsedVertexMap[oldVertex]].xy();
#ifdef DEBUG_PROJECTION
assert(testPointsAreInOppositeSidesOfEdge(oldVertex_currentFace_oldUVSpace, newVertex_currentFace_oldUVSpace, edge0_currentFace_oldUVSpace, edge1_currentFace_oldUVSpace));
#endif
}
else
{
// If there's no UV island border, just use the previous uvs
pv0 = pVertices[pi0].Uv;
pv1 = pVertices[pi1].Uv;
pv2 = pVertices[pi2].Uv;
pv0_proj = projectedPositions[pi0].xy();
pv1_proj = projectedPositions[pi1].xy();
pv2_proj = projectedPositions[pi2].xy();
}
FVector2f v2 = pVertices[newVertex].Uv;
// New vertex baricentric coords in respect to old triangle
float a, b, c;
GetBarycentricCoords(v2, pv0, pv1, pv2, a, b, c);
FVector2f newVertex_proj = pv0_proj * a + pv1_proj * b + pv2_proj * c;
#ifdef DEBUG_PROJECTION
FVector2f v2Test = pv0 * a + pv1 * b + pv2 * c;
float v2TestDist = length(v2 - v2Test);
assert(v2TestDist < 0.001f);
float a2, b2, c2;
GetBarycentricCoords(newVertex_proj, pv0_proj, pv1_proj, pv2_proj, a2, b2, c2);
assert(fabs(a - a2) < 0.5f);
assert(fabs(b - b2) < 0.5f);
assert(fabs(c - c2) < 0.5f);
assert(testPointsAreInOppositeSidesOfEdge(projectedPositions[collapsedVertexMap[oldVertex]].xy(), newVertex_proj,
projectedPositions[collapsedVertexMap[oldVertices[0]]].xy(), projectedPositions[collapsedVertexMap[oldVertices[1]]].xy()));
#endif
int32 collapsedNewVertex = collapsedVertexMap[newVertex];
processedVertices.Add(collapsedNewVertex);
projectedPositions[collapsedNewVertex].pos0 = newVertex_proj[0];
projectedPositions[collapsedNewVertex].pos1 = newVertex_proj[1];
projectedPositions[collapsedNewVertex].pos2 = projectedPositions[oldVertices[0]].pos2;
projectedPositions[collapsedNewVertex].mask3 = newVertex_proj[0] >= 0.0f && newVertex_proj[0] <= 1.0f &&
newVertex_proj[1] >= 0.0f && newVertex_proj[1] <= 1.0f;
// Copy the new info to all the vertices that collapse to the same vertex
TArray<int32> FoundValues;
collapsedVertsMap.MultiFind(collapsedNewVertex,FoundValues);
for (int32 otherVert : FoundValues)
{
processedVertices.Add(otherVert);
projectedPositions[otherVert] = projectedPositions[collapsedNewVertex];
}
//float oldRatio = getTriangleRatio(pVertices[newVertex].uv, pVertices[oldVertices[0]].uv, pVertices[oldVertices[1]].uv);
//float newRatio = getTriangleRatio(newVertex_proj, projectedPositions[collapsedVertexMap[oldVertices[0]]].xy(), projectedPositions[collapsedVertexMap[oldVertices[1]]].xy());
//if (fabs(newRatio - oldRatio) > 31.f)
//{
// break;
//}
}
else
{
#ifdef DEBUG_PROJECTION
assert(oldVertices.Num() == 3);
#endif
}
int32 i0 = collapsedVertexMap[pIndices[currentFace * 3 + 0]];
int32 i1 = collapsedVertexMap[pIndices[currentFace * 3 + 1]];
int32 i2 = collapsedVertexMap[pIndices[currentFace * 3 + 2]];
FVector2f v0 = projectedPositions[i0].xy();
FVector2f v1 = projectedPositions[i1].xy();
FVector2f v2 = projectedPositions[i2].xy();
currentTriangleArea = getTriangleArea(v0, v1, v2);
bool currentTriangleHasPositiveArea = currentTriangleArea >= 0.f;
//FVector3f currentFaceNormal = (cross<float>(v1 - v0, v2 - v0));
//if (hitFaceProjectedNormal.z() * currentFaceNormal.z() < 0)
if(hitFaceHasPositiveArea != currentTriangleHasPositiveArea) // Is the current face wound in the opposite direction?
{
discardedWrapAroundFaces.Add(currentFace); // If so, discard it since it's probably a wrap-around face
}
}
bool anyVertexInUVSpace = false;
for (int32 i = 0; i < 3; ++i)
{
int32 v = collapsedVertexMap[pIndices[currentFace * 3 + i]];
if (projectedPositions[v].mask3 == 1) // Is it inside?
{
anyVertexInUVSpace = true;
break;
}
}
bool anyVertexInObjSpaceRange = false;
for (int32 i = 0; i < 3; ++i)
{
int32 v = pIndices[currentFace * 3 + i];
FVector3f r = pVertices[v].Position - out_intersection;
float squaredDist = FVector3f::DotProduct(r, r);
if (squaredDist <= maxDistSquared / 4.f) // Is it inside?
{
anyVertexInObjSpaceRange = true;
break;
}
}
if (anyVertexInUVSpace && anyVertexInObjSpaceRange && !discardedWrapAroundFaces.Contains(currentFace) )
{
#ifdef DEBUG_PROJECTION
assert(currentTriangleArea != -2.f);
#endif
totalUVAreaCovered += fabs(currentTriangleArea);
for(int32 i = 0; i < 3; ++i)
{
int32 neighborFace2 = faceConnectivity[currentFace].faces[i];
int32 newVertex = faceConnectivity[currentFace].newVertices[i];
bool changesUVIsland = faceConnectivity[currentFace].changesUVIsland[i];
if (neighborFace2 >= 0 && !processedFaces.Contains(neighborFace2) && pendingFacesUnique.Contains(neighborFace2) == 0)
{
NeighborFace neighborFaceStruct;
neighborFaceStruct.neighborFace = neighborFace2;
neighborFaceStruct.newVertex = newVertex;
neighborFaceStruct.previousFace = currentFace;
neighborFaceStruct.numUVIslandChanges = currentFaceStruct.changesUVIsland ? currentFaceStruct.numUVIslandChanges + 1
: currentFaceStruct.numUVIslandChanges;
neighborFaceStruct.step = step;
neighborFaceStruct.changesUVIsland = changesUVIsland;
pendingFaces.Add(neighborFaceStruct);
pendingFacesUnique.Add(neighborFace2);
}
}
}
else
{
discardedWrapAroundFaces.Add(currentFace);
}
//if(step == 1000)
//{
// break;
//}
if (totalUVAreaCovered > 1.5f)
{
break;
}
step++;
}
}
TArray<int32> oldToNewVertex;
oldToNewVertex.Init(-1,vertexCount);
// Add the projected face
for(int32 f : processedFaces)
{
if (discardedWrapAroundFaces.Contains(f))
{
continue;
}
#ifdef DEBUG_PROJECTION
int32 i0 = pIndices[f * 3 + 0];
int32 i1 = pIndices[f * 3 + 1];
int32 i2 = pIndices[f * 3 + 2];
assert(processedVertices.count(i0));
assert(processedVertices.count(i1));
assert(processedVertices.count(i2));
assert(i0 >= 0 && i0 < vertexCount);
assert(i1 >= 0 && i1 < vertexCount);
assert(i2 >= 0 && i2 < vertexCount);
#endif
//// TODO: This test is wrong and may fail for big triangles! Do proper triangle-quad culling.
//if ( projectedPositions[i0][3] > 0.0f ||
// projectedPositions[i1][3] > 0.0f ||
// projectedPositions[i2][3] > 0.0f )
{
// This face is required.
for (int32 v = 0; v < 3; ++v)
{
int32 i = pIndices[f * 3 + v];
#ifdef DEBUG_PROJECTION
assert(i >= 0 && i < vertexCount);
#endif
if (oldToNewVertex[i] < 0)
{
pResultVertices[currentVertex] = pVertices[i];
// \TOOD: Optimize
{
switch (LayoutBlockType)
{
case EMeshBufferFormat::UInt64:
{
const uint64* LayoutBlockIds = reinterpret_cast<const uint64*>(pMesh->GetVertexBuffers().GetBufferData(1));
pResultLayoutBlockIds[currentVertex] = LayoutBlockIds[i];
break;
}
case EMeshBufferFormat::UInt16:
{
const uint16* LayoutBlockIds = reinterpret_cast<const uint16*>(pMesh->GetVertexBuffers().GetBufferData(1));
uint64 BlockId = (uint64(pMesh->MeshIDPrefix) << 32) | uint64(LayoutBlockIds[i]);
pResultLayoutBlockIds[currentVertex] = BlockId;
break;
}
default:
// Not implemented?
check(false);
break;
}
}
pResultVertices[currentVertex].Position[0] = projectedPositions[i].pos0;
pResultVertices[currentVertex].Position[1] = projectedPositions[i].pos1;
pResultVertices[currentVertex].Position[2] = projectedPositions[i].pos2;
// Normal is actually the fade factor
constexpr float MaxGradient = 10.f;
const int32 Step = faceStep[f];
float StepGradient = FMath::Min(Step, MaxGradient) / MaxGradient;
float FadeFactor = 1.0f - StepGradient; //1.f; // dot(pVertices[i].Normal, projectorDirection * -1.0f);
pResultVertices[currentVertex].Normal[0] = FadeFactor;
pResultVertices[currentVertex].Normal[1] = FadeFactor;
pResultVertices[currentVertex].Normal[2] = FadeFactor;
oldToNewVertex[i] = currentVertex++;
}
pResultIndices[currentIndex++] = oldToNewVertex[i];
}
}
}
}
//-------------------------------------------------------------------------------------------------
void MeshProject_Optimised(FMesh* Result, const FMesh* pMesh, const FProjector& projector, bool& bOutSuccess)
{
MUTABLE_CPUPROFILER_SCOPE(MeshProject_Optimised);
bOutSuccess = true;
FVector3f projectorPosition,projectorDirection,projectorSide,projectorUp;
projectorPosition = FVector3f( projector.position[0], projector.position[1], projector.position[2] );
projector.GetDirectionSideUp( projectorDirection, projectorSide, projectorUp );
FVector3f projectorScale( projector.scale[0], projector.scale[1], projector.scale[2] );
// Create with worse case, shrink later.
int32 vertexCount = pMesh->GetVertexCount();
int32 indexCount = pMesh->GetIndexCount();
int32 currentVertex = 0;
int32 currentIndex = 0;
// At this point the code generation ensures we are working with layout 0
const int32 layout = 0;
switch (projector.type)
{
case EProjectorType::Planar:
case EProjectorType::Cylindrical:
{
CreateMeshOptimisedForProjection(Result, layout);
Result->GetVertexBuffers().SetElementCount(vertexCount);
Result->GetIndexBuffers().SetElementCount(indexCount);
uint32* pResultIndices = reinterpret_cast<uint32*>(Result->GetIndexBuffers().GetBufferData(0));
FOptimizedVertex* pResultVertices = reinterpret_cast<FOptimizedVertex*>(Result->GetVertexBuffers().GetBufferData(0));
// Get the vertices
check(pMesh->GetVertexBuffers().GetElementSize(0)==sizeof(FOptimizedVertex));
const FOptimizedVertex* pVertices = reinterpret_cast<const FOptimizedVertex*>(pMesh->GetVertexBuffers().GetBufferData(0));
// Get the indices
check(pMesh->GetIndexBuffers().GetElementSize(0) == 4);
const uint32* pIndices = reinterpret_cast<const uint32*>(pMesh->GetIndexBuffers().GetBufferData(0));
int32 faceCount = pMesh->GetFaceCount();
if (projector.type==EProjectorType::Planar)
{
MeshProject_Optimised_Planar(pVertices, vertexCount,
pIndices, faceCount,
projectorPosition, projectorDirection,
projectorSide, projectorUp,
projectorScale,
pResultVertices, currentVertex,
pResultIndices, currentIndex);
}
else
{
MeshProject_Optimised_Cylindrical(pVertices, vertexCount,
pIndices, faceCount,
projectorPosition, projectorDirection,
projectorSide, projectorUp,
projectorScale,
pResultVertices, currentVertex,
pResultIndices, currentIndex);
}
break;
}
case EProjectorType::Wrapping:
{
CreateMeshOptimisedForWrappingProjection(Result, layout);
// Wrapping-projection also needs the layout block IDs
Result->GetVertexBuffers().SetElementCount(vertexCount);
Result->GetIndexBuffers().SetElementCount(indexCount);
uint32* pResultIndices = reinterpret_cast<uint32*>(Result->GetIndexBuffers().GetBufferData(0));
FOptimizedVertex* pResultVertices = reinterpret_cast<FOptimizedVertex*>(Result->GetVertexBuffers().GetBufferData(0));
// \TODO: be more flexible with the block id formats?
uint64* pResultLayoutBlockIds = reinterpret_cast<uint64*>(Result->GetVertexBuffers().GetBufferData(1));
MeshProject_Optimised_Wrapping(pMesh,
projectorPosition, projectorDirection,
projectorSide, projectorUp,
projectorScale,
pResultVertices, pResultLayoutBlockIds, currentVertex,
pResultIndices, currentIndex);
break;
}
default:
// Projector type not implemented.
check(false);
bOutSuccess = false;
break;
}
// Shrink result mesh
Result->GetVertexBuffers().SetElementCount(currentVertex);
Result->GetIndexBuffers().SetElementCount(currentIndex);
}
#ifdef DEBUG_PROJECTION
UE_ENABLE_OPTIMIZATION
#endif
//-------------------------------------------------------------------------------------------------
void MeshProject(FMesh* Result, const FMesh* pMesh, const FProjector& projector, bool& bOutSuccess)
{
MUTABLE_CPUPROFILER_SCOPE(MeshProject);
if ( EnumHasAnyFlags(pMesh->Flags, EMeshFlags::ProjectFormat) )
{
// Mesh-optimised version
MeshProject_Optimised(Result, pMesh, projector, bOutSuccess);
}
else if (EnumHasAnyFlags(pMesh->Flags, EMeshFlags::ProjectWrappingFormat))
{
// Mesh-optimised version for wrapping projectors
// \todo: make sure the projector is a wrapping projector
MeshProject_Optimised(Result, pMesh, projector, bOutSuccess);
}
else
{
check(false);
}
if (bOutSuccess)
{
Result->Surfaces.Empty();
Result->EnsureSurfaceData();
Result->ResetStaticFormatFlags();
}
}
//-------------------------------------------------------------------------------------------------
void CreateMeshOptimisedForProjection(FMesh* Result, int32 layout)
{
Result->GetVertexBuffers().SetBufferCount( 1 );
Result->GetIndexBuffers().SetBufferCount( 1 );
EMeshBufferSemantic semantics[3] = { EMeshBufferSemantic::TexCoords, EMeshBufferSemantic::Position, EMeshBufferSemantic::Normal };
int32 semanticIndices[3] = { 0, 0, 0 };
EMeshBufferFormat formats[3] = { EMeshBufferFormat::Float32, EMeshBufferFormat::Float32, EMeshBufferFormat::Float32 };
int32 componentCounts[3] = { 2, 3, 3 };
int32 offsets[3] = { 0, 8, 20 };
semanticIndices[0] = layout;
Result->GetVertexBuffers().SetBuffer
( 0, 32, 3,
semantics, semanticIndices,
formats, componentCounts,
offsets );
EMeshBufferSemantic isemantics[1] = { EMeshBufferSemantic::VertexIndex };
int32 isemanticIndices[1] = { 0 };
EMeshBufferFormat iformats[1] = { EMeshBufferFormat::UInt32 };
int32 icomponentCounts[1] = { 1 };
int32 ioffsets[1] = { 0 };
Result->GetIndexBuffers().SetBuffer
( 0, 4, 1,
isemantics, isemanticIndices,
iformats, icomponentCounts,
ioffsets );
}
//-------------------------------------------------------------------------------------------------
void CreateMeshOptimisedForWrappingProjection(FMesh* Result, int32 LayoutIndex)
{
Result->GetVertexBuffers().SetBufferCount( 2 );
Result->GetIndexBuffers().SetBufferCount( 1 );
EMeshBufferSemantic semantics[3] = { EMeshBufferSemantic::TexCoords, EMeshBufferSemantic::Position, EMeshBufferSemantic::Normal };
int32 semanticIndices[3] = { 0, 0, 0 };
EMeshBufferFormat formats[3] = { EMeshBufferFormat::Float32, EMeshBufferFormat::Float32, EMeshBufferFormat::Float32 };
int32 componentCounts[3] = { 2, 3, 3 };
int32 offsets[3] = { 0, 8, 20 };
semanticIndices[0] = LayoutIndex;
Result->GetVertexBuffers().SetBuffer( 0, 32, 3, semantics, semanticIndices, formats, componentCounts, offsets );
EMeshBufferSemantic LayoutSemantics[1] = { EMeshBufferSemantic::LayoutBlock };
int32 LayoutSemanticIndices[1] = { 0 };
EMeshBufferFormat LayoutFormats[1] = { EMeshBufferFormat::UInt64 };
int32 LayoutComponentCounts[1] = { 1 };
int32 LayoutOffsets[1] = { 0 };
LayoutSemanticIndices[0] = LayoutIndex;
Result->GetVertexBuffers().SetBuffer(1, sizeof(uint64), 1, LayoutSemantics, LayoutSemanticIndices, LayoutFormats, LayoutComponentCounts, LayoutOffsets);
EMeshBufferSemantic isemantics[1] = { EMeshBufferSemantic::VertexIndex };
int32 isemanticIndices[1] = { 0 };
EMeshBufferFormat iformats[1] = { EMeshBufferFormat::UInt32 };
int32 icomponentCounts[1] = { 1 };
int32 ioffsets[1] = { 0 };
Result->GetIndexBuffers().SetBuffer( 0, 4, 1, isemantics, isemanticIndices, iformats, icomponentCounts, ioffsets );
}
}
Reference in New Issue View Git Blame Copy Permalink