void IPlugVST3View::resize(int w, int h)
{
TRACE;
ViewRect newSize = ViewRect(0, 0, w, h);
mExpectingNewSize = true;
plugFrame->resizeView(this, &newSize);
}
LOCAL void ZoomBox_OnLButtonUp(HWND hWnd, int x, int y, UINT keyFlags)
/***********************************************************************/
{
BOOL fGotaRect;
LPDISPLAY lpMyDisplay;
RECT ClientRect;
HWND hOwner;
if ( !fCapture )
return;
ReleaseCapture(); fCapture = FALSE;
if (fSelection)
{
EndSelection( hWnd, NULL, &SelectRect, SL_BOX|SL_NOLIMIT, YES );
if (abs(SelectRect.right-SelectRect.left) <= SMALL_MOVEMENT &&
abs(SelectRect.bottom-SelectRect.top) <= SMALL_MOVEMENT)
fGotaRect = NO;
else
fGotaRect = YES;
}
else
{
fGotaRect = NO;
SelectRect.left = SelectRect.right = StartPoint.x;
SelectRect.top = SelectRect.bottom = StartPoint.y;
Display2File( hWnd, (LPINT)&SelectRect.left, (LPINT)&SelectRect.top );
Display2File( hWnd, (LPINT)&SelectRect.right, (LPINT)&SelectRect.bottom );
}
// clip to file rect
lpMyDisplay = GetDisplayPtr(hWnd);
ClientRect = lpMyDisplay->FileRect;
AstralIntersectRect( &SelectRect, &SelectRect, &ClientRect );
SetFocus(hOldFocus);
EnableMarquee(fMarquee);
hOwner = GetZoomOwner(hWnd);
if (!hOwner)
return;
if (IsIconic(hOwner))
return;
SaveLastView(hOwner);
if ( fGotaRect )
ViewRect(hOwner, &SelectRect, NO);
else
{
Zoom( hOwner, SelectRect.left, SelectRect.top,
( SHIFT ? -100 : ( CONTROL ? +100 : 0 ) ), YES,NO);
}
}
tresult PLUGIN_API IPlugVST3View::getSize(ViewRect* size)
{
TRACE;
if (mPlug->GetGUI())
{
*size = ViewRect(0, 0, mPlug->GetGUI()->Width(), mPlug->GetGUI()->Height());
return kResultTrue;
}
else
{
return kResultFalse;
}
}
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);
}
}
int CAmbitProTView::AmCreateRtmDlg()
{
pDlgRtm = NULL;
CRect ViewRect(0,0,500,700);
GetClientRect(ViewRect);
pDlgRtm = (CDialogRtm *)new CDialogRtm;
if (pDlgRtm)
{
pDlgRtm->Create(IDD_DIALOG_RTM, this);
pDlgRtm->SetWindowPos(NULL, ViewRect.top+20, ViewRect.left, ViewRect.right, ViewRect.bottom, SWP_NOZORDER|SWP_NOACTIVATE);
pDlgRtm->ShowWindow(SW_HIDE);
}
else
{
return 0;
}
return 1;
}
int CAmbitProTView::AmCreateDetailDlg()
{
pDlgDetail = NULL;
CRect ViewRect(0,0,500,700);
GetClientRect(ViewRect);
pDlgDetail = (CDetailLogDlg *)new CDetailLogDlg;
if (pDlgDetail)
{
pDlgDetail->Create(IDD_DETAIL_LOG_DLG, this);
pDlgDetail->SetWindowPos(NULL, ViewRect.top+20, ViewRect.left, ViewRect.right, ViewRect.bottom, SWP_NOZORDER|SWP_NOACTIVATE);
pDlgDetail->ShowWindow(SW_HIDE);
}
else
{
return 0;
}
return 1;
}
//haibin.li 2011/11/07
int CAmbitProTView::AmCreateMainDlg()
{
pDlgMain = NULL;
CRect ViewRect(0,0,500,700);
GetClientRect(ViewRect);
pDlgMain = (CDialogMain *)new CDialogMain;
if (pDlgMain)
{
pDlgMain->Create(IDD_DIALOG_MAIN, this);
pDlgMain->SetWindowPos(NULL, ViewRect.top, ViewRect.left, ViewRect.left+20, ViewRect.bottom, SWP_NOZORDER|SWP_NOACTIVATE);// set dialog size
pDlgMain->ShowWindow(SW_SHOW);
}
else
{
return 0;
}
return 1;
}
int CAmbitProTView::AmCreateSfisDlg()
{
pAmSfisDlg = NULL;
CRect ViewRect(0,0,500,700);
GetClientRect(ViewRect);
pAmSfisDlg = (CAmSfisDlg *)new CAmSfisDlg;
if (pAmSfisDlg)
{
pAmSfisDlg->Create(IDD_SFIS_DLG, this);
pAmSfisDlg->SetWindowPos(NULL, ViewRect.top+20, ViewRect.left, ViewRect.right, ViewRect.bottom, SWP_NOZORDER|SWP_NOACTIVATE);// set dialog size
pAmSfisDlg->ShowWindow(SW_HIDE);
}
else
{
return 0;
}
return 1;
}
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);
});
int CAmbitProTView::AmCreateVirtualSmoDlg()
{
pCVirtualSmoDlg = NULL;
CRect ViewRect(0,0,400,250);
GetClientRect(ViewRect);
pCVirtualSmoDlg = (CVirtualSmo *)new CVirtualSmo;
if (pCVirtualSmoDlg)
{
pCVirtualSmoDlg->Create(IDD_VIR_SMO, this);
//pCVirtualSmoDlg->SetWindowPos(NULL, ViewRect.top+50, ViewRect.left+100, ViewRect.top+400, ViewRect.left+250, SWP_NOZORDER|SWP_NOACTIVATE);// set dialog size
pCVirtualSmoDlg->CenterWindow();
pCVirtualSmoDlg->ActivateTopParent();
pCVirtualSmoDlg->EnsureTopLevelParent();
pCVirtualSmoDlg->SetFocus();
pCVirtualSmoDlg->ShowWindow(SW_HIDE);
}
else
{
return 0;
}
return 1;
}
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);
}
}
void FRCPassPostProcessDeferredDecals::DecodeRTWriteMask(FRenderingCompositePassContext& Context)
{
// @todo: get these values from the RHI?
const uint32 MaskTileSizeX = 8;
const uint32 MaskTileSizeY = 8;
check(GSupportsRenderTargetWriteMask);
FRHICommandListImmediate& RHICmdList = Context.RHICmdList;
FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(RHICmdList);
FTextureRHIRef DBufferTex = SceneContext.DBufferA->GetRenderTargetItem().TargetableTexture;
FIntPoint RTWriteMaskDims(
FMath::DivideAndRoundUp(DBufferTex->GetTexture2D()->GetSizeX(), MaskTileSizeX),
FMath::DivideAndRoundUp(DBufferTex->GetTexture2D()->GetSizeY(), MaskTileSizeY));
// allocate the DBufferMask from the render target pool.
FPooledRenderTargetDesc MaskDesc(FPooledRenderTargetDesc::Create2DDesc(RTWriteMaskDims,
PF_R8_UINT,
FClearValueBinding::White,
TexCreate_None,
TexCreate_UAV | TexCreate_RenderTargetable,
false));
GRenderTargetPool.FindFreeElement(Context.RHICmdList, MaskDesc, SceneContext.DBufferMask, TEXT("DBufferMask"));
FIntRect ViewRect(0, 0, DBufferTex->GetTexture2D()->GetSizeX(), DBufferTex->GetTexture2D()->GetSizeY());
TShaderMapRef< FRTWriteMaskDecodeCS > ComputeShader(Context.GetShaderMap());
SetRenderTarget(Context.RHICmdList, FTextureRHIRef(), FTextureRHIRef());
Context.SetViewportAndCallRHI(ViewRect);
Context.RHICmdList.SetComputeShader(ComputeShader->GetComputeShader());
// set destination
Context.RHICmdList.SetUAVParameter(ComputeShader->GetComputeShader(), ComputeShader->OutCombinedRTWriteMask.GetBaseIndex(), SceneContext.DBufferMask->GetRenderTargetItem().UAV);
ComputeShader->SetCS(Context.RHICmdList, Context, Context.View, RTWriteMaskDims);
RHICmdList.TransitionResource(EResourceTransitionAccess::EWritable, EResourceTransitionPipeline::EGfxToCompute, SceneContext.DBufferMask->GetRenderTargetItem().UAV);
{
SCOPED_DRAW_EVENTF(Context.RHICmdList, DeferredDecals, TEXT("Combine DBuffer RTWriteMasks"));
FIntPoint ThreadGroupCountValue(
FMath::DivideAndRoundUp((uint32)RTWriteMaskDims.X, FRTWriteMaskDecodeCS::ThreadGroupSizeX),
FMath::DivideAndRoundUp((uint32)RTWriteMaskDims.Y, FRTWriteMaskDecodeCS::ThreadGroupSizeY));
DispatchComputeShader(Context.RHICmdList, *ComputeShader, ThreadGroupCountValue.X, ThreadGroupCountValue.Y, 1);
}
// void FD3D11DynamicRHI::RHIGraphicsWaitOnAsyncComputeJob( uint32 FenceIndex )
Context.RHICmdList.FlushComputeShaderCache();
RHICmdList.TransitionResource(EResourceTransitionAccess::EReadable, EResourceTransitionPipeline::EComputeToGfx, SceneContext.DBufferMask->GetRenderTargetItem().UAV);
RHICmdList.TransitionResource(EResourceTransitionAccess::EMetaData, SceneContext.DBufferA->GetRenderTargetItem().TargetableTexture);
RHICmdList.TransitionResource(EResourceTransitionAccess::EMetaData, SceneContext.DBufferB->GetRenderTargetItem().TargetableTexture);
RHICmdList.TransitionResource(EResourceTransitionAccess::EMetaData, SceneContext.DBufferC->GetRenderTargetItem().TargetableTexture);
// un-set destination
Context.RHICmdList.SetUAVParameter(ComputeShader->GetComputeShader(), ComputeShader->OutCombinedRTWriteMask.GetBaseIndex(), NULL);
}
static FSceneView& CreateSceneView( FSceneViewFamilyContext& ViewFamilyContext, FSlateBackBuffer& BackBuffer, const FMatrix& ViewProjectionMatrix )
{
FIntRect ViewRect(FIntPoint(0, 0), BackBuffer.GetSizeXY());
// make a temporary view
FSceneViewInitOptions ViewInitOptions;
ViewInitOptions.ViewFamily = &ViewFamilyContext;
ViewInitOptions.SetViewRectangle(ViewRect);
ViewInitOptions.ViewOrigin = FVector::ZeroVector;
ViewInitOptions.ViewRotationMatrix = FMatrix::Identity;
ViewInitOptions.ProjectionMatrix = ViewProjectionMatrix;
ViewInitOptions.BackgroundColor = FLinearColor::Black;
ViewInitOptions.OverlayColor = FLinearColor::White;
FSceneView* View = new FSceneView( ViewInitOptions );
ViewFamilyContext.Views.Add( View );
/** The view transform, starting from world-space points translated by -ViewOrigin. */
FMatrix EffectiveTranslatedViewMatrix = FTranslationMatrix(-View->ViewMatrices.PreViewTranslation) * View->ViewMatrices.ViewMatrix;
// Create the view's uniform buffer.
FViewUniformShaderParameters ViewUniformShaderParameters;
ViewUniformShaderParameters.TranslatedWorldToClip = View->ViewMatrices.TranslatedViewProjectionMatrix;
ViewUniformShaderParameters.WorldToClip = ViewProjectionMatrix;
ViewUniformShaderParameters.TranslatedWorldToView = EffectiveTranslatedViewMatrix;
ViewUniformShaderParameters.ViewToTranslatedWorld = View->InvViewMatrix * FTranslationMatrix(View->ViewMatrices.PreViewTranslation);
ViewUniformShaderParameters.ViewToClip = View->ViewMatrices.ProjMatrix;
ViewUniformShaderParameters.ClipToTranslatedWorld = View->ViewMatrices.InvTranslatedViewProjectionMatrix;
ViewUniformShaderParameters.ViewForward = EffectiveTranslatedViewMatrix.GetColumn(2);
ViewUniformShaderParameters.ViewUp = EffectiveTranslatedViewMatrix.GetColumn(1);
ViewUniformShaderParameters.ViewRight = EffectiveTranslatedViewMatrix.GetColumn(0);
ViewUniformShaderParameters.InvDeviceZToWorldZTransform = View->InvDeviceZToWorldZTransform;
ViewUniformShaderParameters.ScreenPositionScaleBias = FVector4(0,0,0,0);
ViewUniformShaderParameters.ViewRectMin = FVector4(ViewRect.Min.X, ViewRect.Min.Y, 0.0f, 0.0f);
ViewUniformShaderParameters.ViewSizeAndSceneTexelSize = FVector4(ViewRect.Width(), ViewRect.Height(), 1.0f/ViewRect.Width(), 1.0f/ViewRect.Height() );
ViewUniformShaderParameters.ViewOrigin = View->ViewMatrices.ViewOrigin;
ViewUniformShaderParameters.TranslatedViewOrigin = View->ViewMatrices.ViewOrigin + View->ViewMatrices.PreViewTranslation;
ViewUniformShaderParameters.DiffuseOverrideParameter = View->DiffuseOverrideParameter;
ViewUniformShaderParameters.SpecularOverrideParameter = View->SpecularOverrideParameter;
ViewUniformShaderParameters.NormalOverrideParameter = View->NormalOverrideParameter;
ViewUniformShaderParameters.RoughnessOverrideParameter = View->RoughnessOverrideParameter;
ViewUniformShaderParameters.PrevFrameGameTime = View->Family->CurrentWorldTime - View->Family->DeltaWorldTime;
ViewUniformShaderParameters.PrevFrameRealTime = View->Family->CurrentRealTime - View->Family->DeltaWorldTime;
ViewUniformShaderParameters.PreViewTranslation = View->ViewMatrices.PreViewTranslation;
ViewUniformShaderParameters.CullingSign = View->bReverseCulling ? -1.0f : 1.0f;
ViewUniformShaderParameters.NearPlane = GNearClippingPlane;
ViewUniformShaderParameters.GameTime = View->Family->CurrentWorldTime;
ViewUniformShaderParameters.RealTime = View->Family->CurrentRealTime;
ViewUniformShaderParameters.Random = FMath::Rand();
ViewUniformShaderParameters.FrameNumber = View->Family->FrameNumber;
ViewUniformShaderParameters.DirectionalLightShadowTexture = GWhiteTexture->TextureRHI;
ViewUniformShaderParameters.DirectionalLightShadowSampler = TStaticSamplerState<SF_Point, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI();
ViewUniformShaderParameters.ScreenToWorld = FMatrix(
FPlane(1, 0, 0, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, View->ProjectionMatrixUnadjustedForRHI.M[2][2], 1),
FPlane(0, 0, View->ProjectionMatrixUnadjustedForRHI.M[3][2], 0))
* View->InvViewProjectionMatrix;
ViewUniformShaderParameters.ScreenToTranslatedWorld = FMatrix(
FPlane(1, 0, 0, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, View->ProjectionMatrixUnadjustedForRHI.M[2][2], 1),
FPlane(0, 0, View->ProjectionMatrixUnadjustedForRHI.M[3][2], 0))
* View->ViewMatrices.InvTranslatedViewProjectionMatrix;
View->UniformBuffer = TUniformBufferRef<FViewUniformShaderParameters>::CreateUniformBufferImmediate(ViewUniformShaderParameters, UniformBuffer_SingleFrame);
return *View;
}
void FThumbnailPreviewScene::GetView(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));
if (ViewRect.Width() > 0 && ViewRect.Height() > 0)
{
const float FOVDegrees = 30.f;
const float HalfFOVRadians = FMath::DegreesToRadians<float>(FOVDegrees) * 0.5f;
static_assert((int32)ERHIZBuffer::IsInverted != 0, "Check NearPlane and Projection Matrix");
const float NearPlane = 1.0f;
FMatrix ProjectionMatrix = FReversedZPerspectiveMatrix(
HalfFOVRadians,
1.0f,
1.0f,
NearPlane
);
FVector Origin(0);
float OrbitPitch = 0;
float OrbitYaw = 0;
float OrbitZoom = 0;
GetViewMatrixParameters(FOVDegrees, Origin, OrbitPitch, OrbitYaw, 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);
FMatrix ViewRotationMatrix = FRotationMatrix( FRotator(0, OrbitYaw, 0) ) *
FRotationMatrix( FRotator(0, 0, OrbitPitch) ) *
FTranslationMatrix( FVector(0, OrbitZoom, 0) ) *
FInverseRotationMatrix( RotationOffsetToViewCenter );
ViewRotationMatrix = ViewRotationMatrix * FMatrix(
FPlane(0, 0, 1, 0),
FPlane(1, 0, 0, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, 0, 1));
Origin -= ViewRotationMatrix.InverseTransformPosition( FVector::ZeroVector );
ViewRotationMatrix = ViewRotationMatrix.RemoveTranslation();
FSceneViewInitOptions ViewInitOptions;
ViewInitOptions.ViewFamily = ViewFamily;
ViewInitOptions.SetViewRectangle(ViewRect);
ViewInitOptions.ViewOrigin = -Origin;
ViewInitOptions.ViewRotationMatrix = ViewRotationMatrix;
ViewInitOptions.ProjectionMatrix = ProjectionMatrix;
ViewInitOptions.BackgroundColor = FLinearColor::Black;
FSceneView* NewView = new FSceneView(ViewInitOptions);
ViewFamily->Views.Add(NewView);
NewView->StartFinalPostprocessSettings( ViewInitOptions.ViewOrigin );
NewView->EndFinalPostprocessSettings(ViewInitOptions);
FFinalPostProcessSettings::FCubemapEntry& CubemapEntry = *new(NewView->FinalPostProcessSettings.ContributingCubemaps) FFinalPostProcessSettings::FCubemapEntry;
CubemapEntry.AmbientCubemap = GUnrealEd->GetThumbnailManager()->AmbientCubemap;
const float AmbientCubemapIntensity = 1.69;
CubemapEntry.AmbientCubemapTintMulScaleValue = FLinearColor::White * AmbientCubemapIntensity;
// 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, SizeX / FMath::Tan( FOVDegrees ) );
}
}
//------------------------------------------------------------------------------
Rect::operator ViewRect () const
{
return ViewRect (left, top, right, bottom);
}