FMatrix FMatrix::Vycher( int i, int j ) const
{
if ( row <= 1 )
return FMatrix( 1, 1 );
if ( col <= 1 )
return FMatrix( 1, 1 );
int rrr = row, ccc = col;
if ( 1 <= i && i <= row )
rrr--;
if ( 1 <= j && j <= col )
ccc--;
FMatrix d( rrr, ccc );
int r, c, r2, c2;
for ( r = 1, r2 = 1;r <= row;r++, r2++ )
{
if ( i == r )
--r2;
for ( c = 1, c2 = 1;c <= col;c++, c2++ )
{
if ( j == c )
--c2;
if ( r != i && c != j )
d( r2, c2 ) = operator() ( r,c );
}
}
return d;
}
FMatrix OSVRHMDDescription::GetProjectionMatrix(EEye Eye) const
{
// @TODO: a proper stereo projection matrix should be calculated
const float ProjectionCenterOffset = 0.151976421f;
const float PassProjectionOffset = (Eye == LEFT_EYE) ? ProjectionCenterOffset : -ProjectionCenterOffset;
#if 1
const float HalfFov = FMath::DegreesToRadians(GetFov(Eye).X) / 2.f;
const float InWidth = GetDisplaySize(Eye).X;
const float InHeight = GetDisplaySize(Eye).Y;
const float XS = 1.0f / tan(HalfFov);
const float YS = InWidth / tan(HalfFov) / InHeight;
#else
const float HalfFov = 2.19686294f / 2.f;
const float InWidth = 640.f;
const float InHeight = 480.f;
const float XS = 1.0f / tan(HalfFov);
const float YS = InWidth / tan(HalfFov) / InHeight;
#endif
const float InNearZ = GNearClippingPlane;
return FMatrix(
FPlane(XS, 0.0f, 0.0f, 0.0f),
FPlane(0.0f, YS, 0.0f, 0.0f),
FPlane(0.0f, 0.0f, 0.0f, 1.0f),
FPlane(0.0f, 0.0f, InNearZ, 0.0f))
*
FTranslationMatrix(FVector(PassProjectionOffset, 0, 0));
}
void FSceneView::UpdateViewMatrix()
{
FVector StereoViewLocation = ViewLocation;
if (GEngine->IsStereoscopic3D() && StereoPass != eSSP_FULL)
{
GEngine->StereoRenderingDevice->CalculateStereoViewOffset(StereoPass, ViewRotation, WorldToMetersScale, StereoViewLocation);
ViewLocation = StereoViewLocation;
}
ViewMatrices.ViewOrigin = StereoViewLocation;
ViewMatrices.ViewMatrix = FTranslationMatrix(-StereoViewLocation);
ViewMatrices.ViewMatrix = ViewMatrices.ViewMatrix * FInverseRotationMatrix(ViewRotation);
ViewMatrices.ViewMatrix = ViewMatrices.ViewMatrix * FMatrix(
FPlane(0, 0, 1, 0),
FPlane(1, 0, 0, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, 0, 1));
ViewMatrices.PreViewTranslation = -ViewMatrices.ViewOrigin;
FMatrix TranslatedViewMatrix = FTranslationMatrix(-ViewMatrices.PreViewTranslation) * ViewMatrices.ViewMatrix;
// Compute a transform from view origin centered world-space to clip space.
ViewMatrices.TranslatedViewProjectionMatrix = TranslatedViewMatrix * ViewMatrices.ProjMatrix;
ViewMatrices.InvTranslatedViewProjectionMatrix = ViewMatrices.TranslatedViewProjectionMatrix.Inverse();
ViewProjectionMatrix = ViewMatrices.GetViewProjMatrix();
InvViewMatrix = ViewMatrices.GetInvViewMatrix();
InvViewProjectionMatrix = ViewMatrices.GetInvViewProjMatrix();
}
FMatrix ConvertLeapBasisMatrix(Leap::Matrix LeapMatrix)
{
/*
Leap Basis depends on hand type with -z, x, y as general format. This then needs to be inverted to point correctly (x = forward), which yields the matrix below.
*/
FVector InX, InY, InZ, InW;
InX.Set(LeapMatrix.zBasis.z, -LeapMatrix.zBasis.x, -LeapMatrix.zBasis.y);
InY.Set(-LeapMatrix.xBasis.z, LeapMatrix.xBasis.x, LeapMatrix.xBasis.y);
InZ.Set(-LeapMatrix.yBasis.z, LeapMatrix.yBasis.x, LeapMatrix.yBasis.y);
InW.Set(-LeapMatrix.origin.z, LeapMatrix.origin.x, LeapMatrix.origin.y);
if (LeapShouldAdjustForFacing)
{
InX = AdjustForLeapFacing(InX);
InY = AdjustForLeapFacing(InY);
InZ = AdjustForLeapFacing(InZ);
InW = AdjustForLeapFacing(InW);
if (LeapShouldAdjustRotationForHMD)
{
InX = adjustForHMDOrientation(InX);
InY = adjustForHMDOrientation(InY);
InZ = adjustForHMDOrientation(InZ);
InW = adjustForHMDOrientation(InW);
}
}
return (FMatrix(InX, InY, InZ, InW));
}
void FScene::UpdateSceneCaptureContents(USceneCaptureComponent2D* CaptureComponent)
{
check(CaptureComponent);
if (CaptureComponent->TextureTarget)
{
const FTransform& Transform = CaptureComponent->GetComponentToWorld();
FMatrix ViewMatrix = Transform.ToInverseMatrixWithScale();
FVector ViewLocation = Transform.GetTranslation();
// swap axis st. x=z,y=x,z=y (unreal coord space) so that z is up
ViewMatrix = ViewMatrix * FMatrix(
FPlane(0, 0, 1, 0),
FPlane(1, 0, 0, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, 0, 1));
const float FOV = CaptureComponent->FOVAngle * (float)PI / 360.0f;
const bool bUseSceneColorTexture = CaptureComponent->CaptureSource == SCS_SceneColorHDR;
FSceneRenderer* SceneRenderer = CreateSceneRenderer(CaptureComponent, CaptureComponent->TextureTarget, ViewMatrix , ViewLocation, FOV, CaptureComponent->MaxViewDistanceOverride, bUseSceneColorTexture, &CaptureComponent->PostProcessSettings, CaptureComponent->PostProcessBlendWeight);
FTextureRenderTargetResource* TextureRenderTarget = CaptureComponent->TextureTarget->GameThread_GetRenderTargetResource();
const FName OwnerName = CaptureComponent->GetOwner() ? CaptureComponent->GetOwner()->GetFName() : NAME_None;
ENQUEUE_UNIQUE_RENDER_COMMAND_FOURPARAMETER(
CaptureCommand,
FSceneRenderer*, SceneRenderer, SceneRenderer,
FTextureRenderTargetResource*, TextureRenderTarget, TextureRenderTarget,
FName, OwnerName, OwnerName,
bool, bUseSceneColorTexture, bUseSceneColorTexture,
{
UpdateSceneCaptureContent_RenderThread(RHICmdList, SceneRenderer, TextureRenderTarget, OwnerName, FResolveParams(), bUseSceneColorTexture);
});
}
void SetParameters(FRHICommandList& RHICmdList, const FSceneView& View, const FMaterialRenderProxy* MaterialProxy, const FDeferredDecalProxy& DecalProxy, const float FadeAlphaValue=1.0f)
{
const FPixelShaderRHIParamRef ShaderRHI = GetPixelShader();
FMaterialShader::SetParameters(RHICmdList, ShaderRHI, MaterialProxy, *MaterialProxy->GetMaterial(View.GetFeatureLevel()), View, true, ESceneRenderTargetsMode::SetTextures);
FTransform ComponentTrans = DecalProxy.ComponentTrans;
FMatrix WorldToComponent = ComponentTrans.ToInverseMatrixWithScale();
// Set the transform from screen space to light space.
if(ScreenToDecal.IsBound())
{
const FMatrix ScreenToDecalValue =
FMatrix(
FPlane(1,0,0,0),
FPlane(0,1,0,0),
FPlane(0,0,View.ViewMatrices.ProjMatrix.M[2][2],1),
FPlane(0,0,View.ViewMatrices.ProjMatrix.M[3][2],0)
) * View.InvViewProjectionMatrix * WorldToComponent;
SetShaderValue(RHICmdList, ShaderRHI, ScreenToDecal, ScreenToDecalValue);
}
// Set the transform from light space to world space
if(DecalToWorld.IsBound())
{
const FMatrix DecalToWorldValue = ComponentTrans.ToMatrixWithScale();
SetShaderValue(RHICmdList, ShaderRHI, DecalToWorld, DecalToWorldValue);
}
SetShaderValue(RHICmdList, ShaderRHI, FadeAlpha, FadeAlphaValue);
SetShaderValue(RHICmdList, ShaderRHI, WorldToDecal, WorldToComponent);
}
void FCoreAudioDevice::UpdateHardware()
{
// Caches the matrix used to transform a sounds position into local space so we can just look
// at the Y component after normalization to determine spatialization.
const FVector Up = Listeners[0].GetUp();
const FVector Right = Listeners[0].GetFront();
InverseTransform = FMatrix(Up, Right, Up ^ Right, Listeners[0].Transform.GetTranslation()).InverseFast();
}
FSlateD3DRenderer::FSlateD3DRenderer( const ISlateStyle& InStyle )
{
ViewMatrix = FMatrix( FPlane(1, 0, 0, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, 1, 0),
FPlane(0, 0, 0, 1));
}
virtual FMatrixBasePtr subset(const std::vector<bool>::const_iterator &begin,
const std::vector<bool>::const_iterator &end) const override {
boost::shared_ptr<Self> matrix = boost::shared_ptr<Self>(new Self());
for(size_t i = 0; i < m_matrices.size(); i++) {
matrix->m_matrices.push_back(FMatrix(m_matrices[i]->subset(begin, end)));
}
return matrix;
}
FSlateOpenGLRenderer::FSlateOpenGLRenderer( const ISlateStyle& InStyle )
: Style( InStyle )
{
ViewMatrix = FMatrix( FPlane(1, 0, 0, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, 1, 0),
FPlane(0, 0, 0, 1));
}
void PCL_FUNC InPlaceSVDImplementation( FMatrix& A, FVector& W, FMatrix& V )
{
A.SetUnique();
int m = A.Rows();
int n = A.Columns();
W = FVector( n );
V = FMatrix( n, n );
if ( (*API->Numerical->SVDInPlaceF)( A.DataPtr(), W.DataPtr(), V.DataPtr(), m, n ) == api_false )
throw APIFunctionError( "SVDInPlaceF" );
}
FMatrix FCanvas::CalcBaseTransform2D(uint32 ViewSizeX, uint32 ViewSizeY)
{
return AdjustProjectionMatrixForRHI(
FTranslationMatrix(FVector(-GPixelCenterOffset,-GPixelCenterOffset,0)) *
FMatrix(
FPlane( 1.0f / (ViewSizeX / 2.0f), 0.0, 0.0f, 0.0f ),
FPlane( 0.0f, -1.0f / (ViewSizeY / 2.0f), 0.0f, 0.0f ),
FPlane( 0.0f, 0.0f, 1.0f, 0.0f ),
FPlane( -1.0f, 1.0f, 0.0f, 1.0f )
)
);
}
FMatrix UHand::basis()
{
Leap::Matrix matrix;
FVector inX, inY, inZ, inW;
matrix = _hand.basis();
inX.Set(matrix.xBasis.x, matrix.xBasis.y, matrix.xBasis.z);
inY.Set(matrix.xBasis.x, matrix.xBasis.y, matrix.xBasis.z);
inZ.Set(matrix.xBasis.x, matrix.xBasis.y, matrix.xBasis.z);
inW.Set(matrix.xBasis.x, matrix.xBasis.y, matrix.xBasis.z);
return (FMatrix(inX, inY, inZ, inW));
}
FSceneView* FJavascriptUMGViewportClient::CalcSceneView(FSceneViewFamily* ViewFamily)
{
FSceneViewInitOptions ViewInitOptions;
const FVector& ViewLocation = GetViewLocation();
const FRotator& ViewRotation = GetViewRotation();
const FIntPoint ViewportSizeXY = Viewport->GetSizeXY();
FIntRect ViewRect = FIntRect(0, 0, ViewportSizeXY.X, ViewportSizeXY.Y);
ViewInitOptions.SetViewRectangle(ViewRect);
ViewInitOptions.ViewOrigin = ViewLocation;
ViewInitOptions.ViewRotationMatrix = FInverseRotationMatrix(ViewRotation);
ViewInitOptions.ViewRotationMatrix = ViewInitOptions.ViewRotationMatrix * FMatrix(
FPlane(0, 0, 1, 0),
FPlane(1, 0, 0, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, 0, 1));
//@TODO: Should probably be locally configurable (or just made into a FMinimalViewInfo property)
const EAspectRatioAxisConstraint AspectRatioAxisConstraint = GetDefault<ULocalPlayer>()->AspectRatioAxisConstraint;
FMinimalViewInfo::CalculateProjectionMatrixGivenView(ViewInfo, AspectRatioAxisConstraint, Viewport, /*inout*/ ViewInitOptions);
ViewInitOptions.ViewFamily = ViewFamily;
ViewInitOptions.SceneViewStateInterface = ViewState.GetReference();
ViewInitOptions.ViewElementDrawer = this;
ViewInitOptions.BackgroundColor = GetBackgroundColor();
//ViewInitOptions.EditorViewBitflag = 0, // send the bit for this view - each actor will check it's visibility bits against this
// for ortho views to steal perspective view origin
//ViewInitOptions.OverrideLODViewOrigin = FVector::ZeroVector;
//ViewInitOptions.bUseFauxOrthoViewPos = true;
//ViewInitOptions.CursorPos = CurrentMousePos;
FSceneView* View = new FSceneView(ViewInitOptions);
ViewFamily->Views.Add(View);
View->StartFinalPostprocessSettings(ViewLocation);
//OverridePostProcessSettings(*View);
View->EndFinalPostprocessSettings(ViewInitOptions);
return View;
}
void SetParameters(FRHICommandList& RHICmdList, const FSceneView& View, const FMaterialRenderProxy* MaterialProxy, const FDeferredDecalProxy& DecalProxy, const float FadeAlphaValue=1.0f)
{
const FPixelShaderRHIParamRef ShaderRHI = GetPixelShader();
FMaterialShader::SetParameters(RHICmdList, ShaderRHI, MaterialProxy, *MaterialProxy->GetMaterial(View.GetFeatureLevel()), View, View.ViewUniformBuffer, true, ESceneRenderTargetsMode::SetTextures);
FTransform ComponentTrans = DecalProxy.ComponentTrans;
FMatrix WorldToComponent = ComponentTrans.ToInverseMatrixWithScale();
// Set the transform from screen space to light space.
if(SvPositionToDecal.IsBound())
{
FVector2D InvViewSize = FVector2D(1.0f / View.ViewRect.Width(), 1.0f / View.ViewRect.Height());
// setup a matrix to transform float4(SvPosition.xyz,1) directly to Decal (quality, performance as we don't need to convert or use interpolator)
// new_xy = (xy - ViewRectMin.xy) * ViewSizeAndInvSize.zw * float2(2,-2) + float2(-1, 1);
// transformed into one MAD: new_xy = xy * ViewSizeAndInvSize.zw * float2(2,-2) + (-ViewRectMin.xy) * ViewSizeAndInvSize.zw * float2(2,-2) + float2(-1, 1);
float Mx = 2.0f * InvViewSize.X;
float My = -2.0f * InvViewSize.Y;
float Ax = -1.0f - 2.0f * View.ViewRect.Min.X * InvViewSize.X;
float Ay = 1.0f + 2.0f * View.ViewRect.Min.Y * InvViewSize.Y;
// todo: we could use InvTranslatedViewProjectionMatrix and TranslatedWorldToComponent for better quality
const FMatrix SvPositionToDecalValue =
FMatrix(
FPlane(Mx, 0, 0, 0),
FPlane( 0, My, 0, 0),
FPlane( 0, 0, 1, 0),
FPlane(Ax, Ay, 0, 1)
) * View.InvViewProjectionMatrix * WorldToComponent;
SetShaderValue(RHICmdList, ShaderRHI, SvPositionToDecal, SvPositionToDecalValue);
}
// Set the transform from light space to world space
if(DecalToWorld.IsBound())
{
const FMatrix DecalToWorldValue = ComponentTrans.ToMatrixWithScale();
SetShaderValue(RHICmdList, ShaderRHI, DecalToWorld, DecalToWorldValue);
}
SetShaderValue(RHICmdList, ShaderRHI, WorldToDecal, WorldToComponent);
float LifetimeAlpha = FMath::Clamp(View.Family->CurrentWorldTime * -DecalProxy.InvFadeDuration + DecalProxy.FadeStartDelayNormalized, 0.0f, 1.0f);
SetShaderValue(RHICmdList, ShaderRHI, DecalParams, FVector2D(FadeAlphaValue, LifetimeAlpha));
}
FMatrix UHand::rotationMatrix(const ULeapFrame *frame)
{
Leap::Matrix matrix;
Leap::Frame rframe;
FVector inX, inY, inZ, inW;
rframe = frame->getFrame();
matrix = _hand.rotationMatrix(rframe);
inX.Set(matrix.xBasis.x,matrix.xBasis.y,matrix.xBasis.z);
inY.Set(matrix.yBasis.x,matrix.yBasis.y,matrix.yBasis.z);
inZ.Set(matrix.zBasis.x,matrix.zBasis.y,matrix.zBasis.z);
inW.Set(matrix.origin.x,matrix.origin.y,matrix.origin.z);
return (FMatrix(inX, inY, inZ, inW));
}
FMatrix ABrainNormalInteractiveObject::Shear(float firstAxis, float secondAxis)
{
FMatrix shearMatrix;
switch (_shearPlan)
{
case ShearPlan::XY:
shearMatrix = FMatrix(FVector(1, 0, 0),
FVector(0, 1, 0),
FVector(firstAxis, secondAxis, 1),
FVector(0, 0, 0));
break;
case ShearPlan::XZ:
shearMatrix = FMatrix(FVector(1, 0, 0),
FVector(firstAxis, 1, secondAxis),
FVector(0, 0, 1),
FVector(0, 0, 0));
break;
case ShearPlan::YZ:
shearMatrix = FMatrix(FVector(1, firstAxis, secondAxis),
FVector(0, 1, 0),
FVector(0, 0, 1),
FVector(0, 0, 0));
break;
default:
shearMatrix = FMatrix(FVector(1, 0, 0),
FVector(0, 1, 0),
FVector(0, 0, 1),
FVector(0, 0, 0));
break;
}
return shearMatrix;
}
void ULevelThumbnailRenderer::GetView(ULevel* Level, FSceneViewFamily* ViewFamily, int32 X, int32 Y, uint32 SizeX, uint32 SizeY) const
{
check(ViewFamily);
FIntRect ViewRect(
FMath::Max<int32>(X,0),
FMath::Max<int32>(Y,0),
FMath::Max<int32>(X+SizeX,0),
FMath::Max<int32>(Y+SizeY,0));
FBox LevelBox(0);
if (Level->LevelBoundsActor.IsValid())
{
LevelBox = Level->LevelBoundsActor.Get()->GetComponentsBoundingBox();
}
else
{
LevelBox = ALevelBounds::CalculateLevelBounds(Level);
}
if (ViewRect.Width() > 0 && ViewRect.Height() > 0)
{
FSceneViewInitOptions ViewInitOptions;
ViewInitOptions.SetViewRectangle(ViewRect);
ViewInitOptions.ViewFamily = ViewFamily;
const FVector ViewPoint = LevelBox.GetCenter();
ViewInitOptions.ViewMatrix = FMatrix(
FPlane(1, 0, 0, 0),
FPlane(0, -1, 0, 0),
FPlane(0, 0, -1, 0),
FPlane(-ViewPoint.X, ViewPoint.Y, 0, 1));
const float ZOffset = WORLD_MAX;
ViewInitOptions.ProjectionMatrix = FReversedZOrthoMatrix(
LevelBox.GetSize().X/2.f,
LevelBox.GetSize().Y/2.f,
0.5f / ZOffset,
ZOffset
);
FSceneView* NewView = new FSceneView(ViewInitOptions);
ViewFamily->Views.Add(NewView);
}
}
static FMatrix CreateProjectionMatrixD3D( uint32 Width, uint32 Height )
{
// Create ortho projection matrix
const float Left = 0.0f;//0.5f
const float Right = Left+Width;
const float Top = 0.0f;//0.5f
const float Bottom = Top+Height;
const float ZNear = 0;
const float ZFar = 1;
return FMatrix( FPlane(2.0f/(Right-Left), 0, 0, 0 ),
FPlane(0, 2.0f/(Top-Bottom), 0, 0 ),
FPlane(0, 0, 1/(ZNear-ZFar), 0 ),
FPlane((Left+Right)/(Left-Right), (Top+Bottom)/(Bottom-Top), ZNear/(ZNear-ZFar), 1 ) );
}
FMatrix OSVRHMDDescription::GetProjectionMatrix(float left, float right, float bottom, float top, float nearClip, float farClip) const
{
// original code
//float sumRightLeft = static_cast<float>(right + left);
//float sumTopBottom = static_cast<float>(top + bottom);
//float inverseRightLeft = 1.0f / static_cast<float>(right - left);
//float inverseTopBottom = 1.0f / static_cast<float>(top - bottom);
//FPlane row1(2.0f * inverseRightLeft, 0.0f, 0.0f, 0.0f);
//FPlane row2(0.0f, 2.0f * inverseTopBottom, 0.0f, 0.0f);
//FPlane row3((sumRightLeft * inverseRightLeft), (sumTopBottom * inverseTopBottom), 0.0f, 1.0f);
//FPlane row4(0.0f, 0.0f, zNear, 0.0f);
// OSVR Render Manager OSVR_Projection_to_D3D with adjustment for unreal (from steamVR plugin)
OSVR_ProjectionMatrix projection;
projection.left = static_cast<double>(left);
projection.right = static_cast<double>(right);
projection.top = static_cast<double>(top);
projection.bottom = static_cast<double>(bottom);
projection.nearClip = static_cast<double>(nearClip);
// @todo Since farClip may be FLT_MAX, round-trip casting to double
// and back (via the OSVR_Projection_to_Unreal call) it should
// be checked for conversion issues.
projection.farClip = static_cast<double>(farClip);
float p[16];
OSVR_Projection_to_Unreal(p, projection);
FPlane row1(p[0], p[1], p[2], p[3]);
FPlane row2(p[4], p[5], p[6], p[7]);
FPlane row3(p[8], p[9], p[10], p[11]);
FPlane row4(p[12], p[13], p[14], p[15]);
FMatrix ret = FMatrix(row1, row2, row3, row4);
//ret.M[3][3] = 0.0f;
//ret.M[2][3] = 1.0f;
//ret.M[2][2] = 0.0f;
//ret.M[3][2] = nearClip;
// This was suggested by Nick at Epic, but doesn't seem to work? Black screen.
//ret.M[2][2] = nearClip / (nearClip - farClip);
//ret.M[3][2] = -nearClip * nearClip / (nearClip - farClip);
// Adjustment suggested on a forum post for an off-axis projection. Doesn't work.
//ret *= 1.0f / ret.M[0][0];
//ret.M[3][2] = GNearClippingPlane;
return ret;
}
void FCanvas::Construct()
{
check(RenderTarget);
// Push the viewport transform onto the stack. Default to using a 2D projection.
new(TransformStack) FTransformEntry(
FMatrix( CalcBaseTransform2D(RenderTarget->GetSizeXY().X,RenderTarget->GetSizeXY().Y) )
);
// init alpha to 1
AlphaModulate=1.0;
// make sure the LastElementIndex is invalid
LastElementIndex = INDEX_NONE;
// init sort key to 0
PushDepthSortKey(0);
}
FMatrix FSimpleHMD::GetStereoProjectionMatrix(const enum EStereoscopicPass StereoPassType, const float FOV) const
{
const float ProjectionCenterOffset = 0.151976421f;
const float PassProjectionOffset = (StereoPassType == eSSP_LEFT_EYE) ? ProjectionCenterOffset : -ProjectionCenterOffset;
const float HalfFov = 2.19686294f / 2.f;
const float InWidth = 640.f;
const float InHeight = 480.f;
const float XS = 1.0f / tan(HalfFov);
const float YS = InWidth / tan(HalfFov) / InHeight;
const float InNearZ = GNearClippingPlane;
return FMatrix(
FPlane(XS, 0.0f, 0.0f, 0.0f),
FPlane(0.0f, YS, 0.0f, 0.0f),
FPlane(0.0f, 0.0f, 0.0f, 1.0f),
FPlane(0.0f, 0.0f, InNearZ, 0.0f))
* FTranslationMatrix(FVector(PassProjectionOffset,0,0));
}
static FMatrix CreateProjectionMatrix( uint32 Width, uint32 Height )
{
float PixelOffset = GPixelCenterOffset;
// Create ortho projection matrix
const float Left = PixelOffset;
const float Right = Left+Width;
const float Top = PixelOffset;
const float Bottom = Top+Height;
const float ZNear = -100.0f;
const float ZFar = 100.0f;
return AdjustProjectionMatrixForRHI(
FMatrix(
FPlane(2.0f/(Right-Left), 0, 0, 0 ),
FPlane(0, 2.0f/(Top-Bottom), 0, 0 ),
FPlane(0, 0, 1/(ZNear-ZFar), 0 ),
FPlane((Left+Right)/(Left-Right), (Top+Bottom)/(Bottom-Top), ZNear/(ZNear-ZFar), 1 )
)
);
}
FMatrix FSteamVRHMD::GetStereoProjectionMatrix(const enum EStereoscopicPass StereoPassType, const float FOV) const
{
check(IsStereoEnabled());
vr::Hmd_Eye HmdEye = (StereoPassType == eSSP_LEFT_EYE) ? vr::Eye_Left : vr::Eye_Right;
float Left, Right, Top, Bottom;
VRSystem->GetProjectionRaw(HmdEye, &Right, &Left, &Top, &Bottom);
Bottom *= -1.0f;
Top *= -1.0f;
Right *= -1.0f;
Left *= -1.0f;
float ZNear = GNearClippingPlane;
float SumRL = (Right + Left);
float SumTB = (Top + Bottom);
float InvRL = (1.0f / (Right - Left));
float InvTB = (1.0f / (Top - Bottom));
#if 1
FMatrix Mat = FMatrix(
FPlane((2.0f * InvRL), 0.0f, 0.0f, 0.0f),
FPlane(0.0f, (2.0f * InvTB), 0.0f, 0.0f),
FPlane((SumRL * InvRL), (SumTB * InvTB), 0.0f, 1.0f),
FPlane(0.0f, 0.0f, ZNear, 0.0f)
);
#else
vr::HmdMatrix44_t SteamMat = VRSystem->GetProjectionMatrix(HmdEye, ZNear, 10000.0f, vr::API_DirectX);
FMatrix Mat = ToFMatrix(SteamMat);
Mat.M[3][3] = 0.0f;
Mat.M[2][3] = 1.0f;
Mat.M[2][2] = 0.0f;
Mat.M[3][2] = ZNear;
#endif
return Mat;
}
void SetParameters(const FSceneView& View, const FMaterialRenderProxy* MaterialProxy, const FDeferredDecalProxy& DecalProxy)
{
const FPixelShaderRHIParamRef ShaderRHI = GetPixelShader();
FMaterialShader::SetParameters(ShaderRHI, MaterialProxy, *MaterialProxy->GetMaterial(GRHIFeatureLevel), View, true, ESceneRenderTargetsMode::SetTextures);
FTransform ComponentTrans = DecalProxy.ComponentTrans;
// 1,1,1 requires no scale
// ComponentTrans = ComponentTrans.GetScaled(GDefaultDecalSize);
FMatrix WorldToComponent = ComponentTrans.ToMatrixWithScale().Inverse();
// Set the transform from screen space to light space.
if(ScreenToDecal.IsBound())
{
const FMatrix ScreenToDecalValue =
FMatrix(
FPlane(1,0,0,0),
FPlane(0,1,0,0),
FPlane(0,0,View.ViewMatrices.ProjMatrix.M[2][2],1),
FPlane(0,0,View.ViewMatrices.ProjMatrix.M[3][2],0)
) * View.InvViewProjectionMatrix * WorldToComponent;
SetShaderValue(ShaderRHI, ScreenToDecal, ScreenToDecalValue);
}
// Set the transform from light space to world space (only for normals)
if(DecalToWorld.IsBound())
{
const FMatrix DecalToWorldValue = ComponentTrans.ToMatrixNoScale();
// 1,1,1 requires no scale
// DecalToWorldValue = DecalToWorldValue.GetScaled(GDefaultDecalSize);
SetShaderValue(ShaderRHI, DecalToWorld, DecalToWorldValue);
}
}
void FRendererModule::GPUBenchmark(FSynthBenchmarkResults& InOut, float WorkScale)
{
check(IsInGameThread());
FSceneViewInitOptions ViewInitOptions;
FIntRect ViewRect(0, 0, 1, 1);
FBox LevelBox(FVector(-WORLD_MAX), FVector(+WORLD_MAX));
ViewInitOptions.SetViewRectangle(ViewRect);
// Initialize Projection Matrix and ViewMatrix since FSceneView initialization is doing some math on them.
// Otherwise it trips NaN checks.
const FVector ViewPoint = LevelBox.GetCenter();
ViewInitOptions.ViewOrigin = FVector(ViewPoint.X, ViewPoint.Y, 0.0f);
ViewInitOptions.ViewRotationMatrix = FMatrix(
FPlane(1, 0, 0, 0),
FPlane(0, -1, 0, 0),
FPlane(0, 0, -1, 0),
FPlane(0, 0, 0, 1));
const float ZOffset = WORLD_MAX;
ViewInitOptions.ProjectionMatrix = FReversedZOrthoMatrix(
LevelBox.GetSize().X / 2.f,
LevelBox.GetSize().Y / 2.f,
0.5f / ZOffset,
ZOffset
);
FSceneView DummyView(ViewInitOptions);
ENQUEUE_UNIQUE_RENDER_COMMAND_THREEPARAMETER(
RendererGPUBenchmarkCommand,
FSceneView, DummyView, DummyView,
float, WorkScale, WorkScale,
FSynthBenchmarkResults&, InOut, InOut,
{
RendererGPUBenchmark(RHICmdList, InOut, DummyView, WorkScale);
});
void DrawDebugCone(const UWorld* InWorld, FVector const& Origin, FVector const& Direction, float Length, float AngleWidth, float AngleHeight, int32 NumSides, FColor const& DrawColor, bool bPersistentLines, float LifeTime, uint8 DepthPriority)
{
// no debug line drawing on dedicated server
if (GEngine->GetNetMode(InWorld) != NM_DedicatedServer)
{
// Need at least 4 sides
NumSides = FMath::Max(NumSides, 4);
const float Angle1 = FMath::Clamp<float>(AngleHeight, (float)KINDA_SMALL_NUMBER, (float)(PI - KINDA_SMALL_NUMBER));
const float Angle2 = FMath::Clamp<float>(AngleWidth, (float)KINDA_SMALL_NUMBER, (float)(PI - KINDA_SMALL_NUMBER));
const float SinX_2 = FMath::Sin(0.5f * Angle1);
const float SinY_2 = FMath::Sin(0.5f * Angle2);
const float SinSqX_2 = SinX_2 * SinX_2;
const float SinSqY_2 = SinY_2 * SinY_2;
const float TanX_2 = FMath::Tan(0.5f * Angle1);
const float TanY_2 = FMath::Tan(0.5f * Angle2);
TArray<FVector> ConeVerts;
ConeVerts.AddUninitialized(NumSides);
for(int32 i = 0; i < NumSides; i++)
{
const float Fraction = (float)i/(float)(NumSides);
const float Thi = 2.f * PI * Fraction;
const float Phi = FMath::Atan2(FMath::Sin(Thi)*SinY_2, FMath::Cos(Thi)*SinX_2);
const float SinPhi = FMath::Sin(Phi);
const float CosPhi = FMath::Cos(Phi);
const float SinSqPhi = SinPhi*SinPhi;
const float CosSqPhi = CosPhi*CosPhi;
const float RSq = SinSqX_2*SinSqY_2 / (SinSqX_2*SinSqPhi + SinSqY_2*CosSqPhi);
const float R = FMath::Sqrt(RSq);
const float Sqr = FMath::Sqrt(1-RSq);
const float Alpha = R*CosPhi;
const float Beta = R*SinPhi;
ConeVerts[i].X = (1 - 2*RSq);
ConeVerts[i].Y = 2 * Sqr * Alpha;
ConeVerts[i].Z = 2 * Sqr * Beta;
}
// Calculate transform for cone.
FVector YAxis, ZAxis;
FVector DirectionNorm = Direction.SafeNormal();
DirectionNorm.FindBestAxisVectors(YAxis, ZAxis);
const FMatrix ConeToWorld = FScaleMatrix(FVector(Length)) * FMatrix(DirectionNorm, YAxis, ZAxis, Origin);
// this means foreground lines can't be persistent
ULineBatchComponent* const LineBatcher = GetDebugLineBatcher( InWorld, bPersistentLines, LifeTime, (DepthPriority == SDPG_Foreground) );
if(LineBatcher != NULL)
{
float const LineLifeTime = (LifeTime > 0.f) ? LifeTime : LineBatcher->DefaultLifeTime;
TArray<FBatchedLine> Lines;
Lines.Empty(NumSides);
FVector CurrentPoint, PrevPoint, FirstPoint;
for(int32 i = 0; i < NumSides; i++)
{
CurrentPoint = ConeToWorld.TransformPosition(ConeVerts[i]);
Lines.Add(FBatchedLine(ConeToWorld.GetOrigin(), CurrentPoint, DrawColor, LineLifeTime, 0.0f, DepthPriority));
// PrevPoint must be defined to draw junctions
if( i > 0 )
{
Lines.Add(FBatchedLine(PrevPoint, CurrentPoint, DrawColor, LineLifeTime, 0.0f, DepthPriority));
}
else
{
FirstPoint = CurrentPoint;
}
PrevPoint = CurrentPoint;
}
// Connect last junction to first
Lines.Add(FBatchedLine(CurrentPoint, FirstPoint, DrawColor, LineLifeTime, 0.0f, DepthPriority));
LineBatcher->DrawLines(Lines);
}
}
}
//NNFF performs a feedforward pass
double FBNN::nnff(const FMatrix& x, const FMatrix& y)
{
// std::cout << "start nnff x = (" << x.rows() << "," << x.columns() << ")" << std::endl;
double L = 0;
if(m_oAs.empty())
{
for(int i = 0; i < m_iN; ++i)
m_oAs.push_back(std::make_shared<FMatrix>(FMatrix()));
}
*m_oAs[0] = addPreColumn(x,1);
if(m_fDropoutFraction > 0 && !m_fTesting)
{
if(m_odOMs.empty())//clear dropOutMask
{
for(int i = 0; i < m_iN - 1; ++i)
m_odOMs.push_back(std::make_shared<FMatrix>(FMatrix()));
}
}
// std::cout << "start feedforward" << std::endl;
//feedforward pass
for(int i = 1; i < m_iN - 1; ++i)
{
// std::cout << "activation function" << std::endl;
//activation function
if(m_strActivationFunction == "sigm")
{
//Calculate the unit's outputs (including the bias term)
*m_oAs[i] = sigm((*m_oAs[i-1]) * blaze::trans(*m_oWs[i-1]));
}
else if(m_strActivationFunction == "tanh_opt")
{
*m_oAs[i] = tanh_opt((*m_oAs[i-1]) * blaze::trans(*m_oWs[i-1]));
}
// std::cout << "dropout" << std::endl;
//dropout
if(m_fDropoutFraction > 0)
{
if(m_fTesting)
*m_oAs[i] = (*m_oAs[i]) * (1 - m_fDropoutFraction);
else
{
*m_odOMs[i] = rand(m_oAs[i]->rows(),m_oAs[i]->columns()) > m_fDropoutFraction;
*m_oAs[i] = bitWiseMul(*m_oAs[i],*m_odOMs[i]);
}
}
// std::cout << "sparsity" << std::endl;
//calculate running exponential activations for use with sparsity
if(m_fNonSparsityPenalty > 0)
*m_oPs[i] = (*m_oPs[i]) * 0.99 + columnMean(*m_oAs[i]);
// std::cout << "Add the bias term" << std::endl;
//Add the bias term
*m_oAs[i] = addPreColumn(*m_oAs[i],1);
}
// std::cout << "start calculate output" << std::endl;
if(m_strOutput == "sigm")
{
*m_oAs[m_iN -1] = sigm((*m_oAs[m_iN-2]) * blaze::trans(*m_oWs[m_iN-2]));
}
else if(m_strOutput == "linear")
{
*m_oAs[m_iN -1] = (*m_oAs[m_iN-2]) * blaze::trans(*m_oWs[m_iN-2]);
}
else if(m_strOutput == "softmax")
{
*m_oAs[m_iN -1] = softmax((*m_oAs[m_iN-2]) * blaze::trans(*m_oWs[m_iN-2]));
}
// std::cout << "start error and loss" << std::endl;
//error and loss
m_oEp = std::make_shared<FMatrix>(y - (*m_oAs[m_iN-1]));
if(m_strOutput == "sigm" || m_strOutput == "linear")
{
L = 0.5 * matrixSum(bitWiseSquare(*m_oEp)) / x.rows();
}
else if(m_strOutput == "softmax")
{
L = -matrixSum(bitWiseMul(y,bitWiseLog(*m_oAs[m_iN-1]))) / x.rows();
}
// std::cout << "end nnff" << std::endl;
return L;
}
//NNBP performs backpropagation
void FBNN::nnbp(void)
{
// std::cout << "start nnbp" << std::endl;
std::vector<FMatrix_ptr> oDs;
//initialize oDs
for(int i = 0; i < m_iN; i++)
oDs.push_back(std::make_shared<FMatrix>(FMatrix()));
if(m_strOutput == "sigm")
{
*oDs[m_iN -1] = bitWiseMul(*m_oEp,bitWiseMul(*m_oAs[m_iN -1],*m_oAs[m_iN -1] - 1));
}
else if(m_strOutput == "softmax" || m_strOutput == "linear")
{
*oDs[m_iN -1] = - (*m_oEp);
}
for(int i = m_iN - 2; i > 0; i--)
{
FMatrix d_act;
if(m_strActivationFunction == "sigm")
{
d_act = bitWiseMul(*m_oAs[i],1 - (*m_oAs[i]));
}
else if(m_strActivationFunction == "tanh_opt")
{
d_act = 1.7159 * 2/3 - 2/(3 * 1.7159) * bitWiseSquare(*m_oAs[i]);
}
if(m_fNonSparsityPenalty > 0)
{
FMatrix pi = repmat(*m_oPs[i],m_oAs[i]->rows(),1);
FMatrix sparsityError = addPreColumn(m_fNonSparsityPenalty * (1 - m_fSparsityTarget) / (1 - pi) - m_fNonSparsityPenalty * m_fSparsityTarget / pi,0);
//Backpropagate first derivatives
if(i == m_iN - 2)//in this case in oDs there is not the bias term to be removed
{
*oDs[i] = bitWiseMul(*oDs[i+1] * (*m_oWs[i]) + sparsityError,d_act);//Bishop (5.56)
}
else//in this case in oDs the bias term has to be removed
{
*oDs[i] = bitWiseMul(delPreColumn(*oDs[i+1]) * (*m_oWs[i]) + sparsityError,d_act);
}
}
else
{
//Backpropagate first derivatives
if(i == m_iN - 2)//in this case in oDs there is not the bias term to be removed
{
*oDs[i] = bitWiseMul((*oDs[i+1]) * (*m_oWs[i]),d_act);//Bishop (5.56)
}
else//in this case in oDs the bias term has to be removed
{
*oDs[i] = bitWiseMul(delPreColumn(*oDs[i+1]) * (*m_oWs[i]),d_act);
}
}
if(m_fDropoutFraction > 0)
{
*oDs[i] = bitWiseMul(*oDs[i],addPreColumn(*m_odOMs[i],1));
}
}
if(m_odWs.empty())//Initialize m_odWs
{
for(int i = 0; i < m_iN - 1; i++)
{
m_odWs.push_back(std::make_shared<FMatrix>(FMatrix()));
}
}
for(int i = 0; i < m_iN - 1; i++)
{
if(i == m_iN - 2)
{
*m_odWs[i] = trans(*oDs[i+1]) * (*m_oAs[i]) / oDs[i+1]->rows();
}
else
{
*m_odWs[i] = trans(delPreColumn(*oDs[i+1])) * (*m_oAs[i]) / oDs[i+1]->rows();
}
}
// std::cout << "end nnbp" << std::endl;
}
void UWorldThumbnailRenderer::GetView(UWorld* World, FSceneViewFamily* ViewFamily, int32 X, int32 Y, uint32 SizeX, uint32 SizeY) const
{
check(ViewFamily);
check(World);
check(World->PersistentLevel);
FIntRect ViewRect(
FMath::Max<int32>(X, 0),
FMath::Max<int32>(Y, 0),
FMath::Max<int32>(X + SizeX, 0),
FMath::Max<int32>(Y + SizeY, 0));
if (ViewRect.Width() > 0 && ViewRect.Height() > 0)
{
FBox WorldBox(0);
TArray<ULevel*> LevelsToRender = World->GetLevels();
for ( auto* Level : LevelsToRender )
{
if (Level && Level->bIsVisible)
{
ALevelBounds* LevelBounds = Level->LevelBoundsActor.Get();
if (!LevelBounds)
{
// Ensure a Level Bounds Actor exists for future renders
FActorSpawnParameters SpawnParameters;
SpawnParameters.OverrideLevel = Level;
LevelBounds = World->SpawnActor<ALevelBounds>(SpawnParameters);
LevelBounds->UpdateLevelBoundsImmediately();
Level->LevelBoundsActor = LevelBounds;
}
if (!LevelBounds->IsUsingDefaultBounds())
{
WorldBox += LevelBounds->GetComponentsBoundingBox();
}
}
}
UWorldThumbnailInfo* ThumbnailInfo = Cast<UWorldThumbnailInfo>(World->ThumbnailInfo);
if (!ThumbnailInfo)
{
ThumbnailInfo = UWorldThumbnailInfo::StaticClass()->GetDefaultObject<UWorldThumbnailInfo>();
}
const FVector Origin = WorldBox.GetCenter();
FMatrix ViewMatrix = FTranslationMatrix(-Origin);
FMatrix ProjectionMatrix;
float FOVScreenSize = 0; // Screen size taking FOV into account
if (ThumbnailInfo->CameraMode == ECameraProjectionMode::Perspective)
{
const float FOVDegrees = 30.f;
const float HalfFOVRadians = FMath::DegreesToRadians<float>(FOVDegrees) * 0.5f;
const float WorldRadius = WorldBox.GetSize().Size() / 2.f;
float TargetDistance = WorldRadius / FMath::Tan(HalfFOVRadians);
if (ensure(ThumbnailInfo))
{
if (TargetDistance + ThumbnailInfo->OrbitZoom < 0)
{
ThumbnailInfo->OrbitZoom = -TargetDistance;
}
}
float OrbitPitch = GlobalOrbitPitchOffset + ThumbnailInfo->OrbitPitch;
float OrbitYaw = GlobalOrbitYawOffset + ThumbnailInfo->OrbitYaw;
float OrbitZoom = TargetDistance + ThumbnailInfo->OrbitZoom;
// Ensure a minimum camera distance to prevent problems with really small objects
const float MinCameraDistance = 48;
OrbitZoom = FMath::Max<float>(MinCameraDistance, OrbitZoom);
const FRotator RotationOffsetToViewCenter(0.f, 90.f, 0.f);
ViewMatrix = ViewMatrix *
FRotationMatrix(FRotator(0, OrbitYaw, 0)) *
FRotationMatrix(FRotator(0, 0, OrbitPitch)) *
FTranslationMatrix(FVector(0, OrbitZoom, 0)) *
FInverseRotationMatrix(RotationOffsetToViewCenter);
ViewMatrix = ViewMatrix * FMatrix(
FPlane(0, 0, 1, 0),
FPlane(1, 0, 0, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, 0, 1));
const float NearPlane = 1.0f;
ProjectionMatrix = FReversedZPerspectiveMatrix(
HalfFOVRadians,
1.0f,
1.0f,
NearPlane
);
FOVScreenSize = SizeX / FMath::Tan(FOVDegrees);
}
else if (ThumbnailInfo->CameraMode == ECameraProjectionMode::Orthographic)
{
FVector2D WorldSizeMin2D;
FVector2D WorldSizeMax2D;
switch (ThumbnailInfo->OrthoDirection)
{
case EOrthoThumbnailDirection::Top:
ViewMatrix = ViewMatrix * FMatrix(
FPlane(1, 0, 0, 0),
FPlane(0, -1, 0, 0),
FPlane(0, 0, -1, 0),
FPlane(0, 0, Origin.Z, 1));
WorldSizeMin2D = FVector2D(WorldBox.Min.X,WorldBox.Min.Y);
WorldSizeMax2D = FVector2D(WorldBox.Max.X,WorldBox.Max.Y);
break;
case EOrthoThumbnailDirection::Bottom:
ViewMatrix = ViewMatrix * FMatrix(
FPlane(1, 0, 0, 0),
FPlane(0, -1, 0, 0),
FPlane(0, 0, 1, 0),
FPlane(0, 0, Origin.Z, 1));
WorldSizeMin2D = FVector2D(WorldBox.Min.X, WorldBox.Min.Y);
WorldSizeMax2D = FVector2D(WorldBox.Max.X, WorldBox.Max.Y);
break;
case EOrthoThumbnailDirection::Front:
ViewMatrix = ViewMatrix * FMatrix(
FPlane(1, 0, 0, 0),
FPlane(0, 0, -1, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, Origin.Y, 1));
WorldSizeMin2D = FVector2D(WorldBox.Min.X, WorldBox.Min.Z);
WorldSizeMax2D = FVector2D(WorldBox.Max.X, WorldBox.Max.Z);
break;
case EOrthoThumbnailDirection::Back:
ViewMatrix = ViewMatrix * FMatrix(
FPlane(-1, 0, 0, 0),
FPlane(0, 0, 1, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, Origin.Y, 1));
WorldSizeMin2D = FVector2D(WorldBox.Min.X, WorldBox.Min.Z);
WorldSizeMax2D = FVector2D(WorldBox.Max.X, WorldBox.Max.Z);
break;
case EOrthoThumbnailDirection::Left:
ViewMatrix = ViewMatrix * FMatrix(
FPlane(0, 0, -1, 0),
FPlane(-1, 0, 0, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, Origin.X, 1));
WorldSizeMin2D = FVector2D(WorldBox.Min.Y, WorldBox.Min.Z);
WorldSizeMax2D = FVector2D(WorldBox.Max.Y, WorldBox.Max.Z);
break;
case EOrthoThumbnailDirection::Right:
ViewMatrix = ViewMatrix * FMatrix(
FPlane(0, 0, 1, 0),
FPlane(1, 0, 0, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, Origin.X, 1));
WorldSizeMin2D = FVector2D(WorldBox.Min.Y, WorldBox.Min.Z);
WorldSizeMax2D = FVector2D(WorldBox.Max.Y, WorldBox.Max.Z);
break;
default:
// Unknown OrthoDirection
ensureMsgf(false, TEXT("Unknown thumbnail OrthoDirection"));
break;
}
FVector2D WorldSize2D = (WorldSizeMax2D - WorldSizeMin2D);
WorldSize2D.X = FMath::Abs(WorldSize2D.X);
WorldSize2D.Y = FMath::Abs(WorldSize2D.Y);
const bool bUseXAxis = (WorldSize2D.X / WorldSize2D.Y) > 1.f;
const float WorldAxisSize = bUseXAxis ? WorldSize2D.X : WorldSize2D.Y;
const uint32 ViewportAxisSize = bUseXAxis ? SizeX : SizeY;
const float OrthoZoom = WorldAxisSize / ViewportAxisSize / 2.f;
const float OrthoWidth = FMath::Max(1.f, SizeX * OrthoZoom);
const float OrthoHeight = FMath::Max(1.f, SizeY * OrthoZoom);
const float ZOffset = HALF_WORLD_MAX;
ProjectionMatrix = FReversedZOrthoMatrix(
OrthoWidth,
OrthoHeight,
0.5f / ZOffset,
ZOffset
);
FOVScreenSize = SizeX;
}
else
{
// Unknown CameraMode
ensureMsgf(false, TEXT("Unknown thumbnail CameraMode"));
}
FSceneViewInitOptions ViewInitOptions;
ViewInitOptions.ViewFamily = ViewFamily;
ViewInitOptions.SetViewRectangle(ViewRect);
ViewInitOptions.BackgroundColor = FLinearColor::Black;
ViewInitOptions.ViewMatrix = ViewMatrix;
ViewInitOptions.ProjectionMatrix = ProjectionMatrix;
FSceneView* NewView = new FSceneView(ViewInitOptions);
ViewFamily->Views.Add(NewView);
// Tell the texture streaming system about this thumbnail view, so the textures will stream in as needed
// NOTE: Sizes may not actually be in screen space depending on how the thumbnail ends up stretched by the UI. Not a big deal though.
// NOTE: Textures still take a little time to stream if the view has not been re-rendered recently, so they may briefly appear blurry while mips are prepared
// NOTE: Content Browser only renders thumbnails for loaded assets, and only when the mouse is over the panel. They'll be frozen in their last state while the mouse cursor is not over the panel. This is for performance reasons
IStreamingManager::Get().AddViewInformation(Origin, SizeX, FOVScreenSize);
}
}
