glm::vec4 CCamera::GetWeight(const SceneSample& ss)
{
SceneSample cam;
cam.position = GetPosition();
cam.normal = GetViewDirection();
glm::vec3 d_10 = ss.position - cam.position;
glm::vec3 d_01 = cam.position - ss.position;
float w = G(ss, cam) * powf(glm::dot(GetViewDirection(), d_10), 3.f)/glm::dot(ss.normal, d_01) * GetRho();
return glm::vec4(w);
}
SceneSample CCamera::GetCameraAsSceneSample()
{
SceneSample cam;
cam.position = GetPosition();
cam.normal = GetViewDirection();
return cam;
}
void PlayerCharacter::SetAcceleration()
{
// 가속 시작 시점 기록 - 타임 스탬프로 문제 해결
// 나중에는 타이머 만들어서 써볼까?
m_AccelerationStart = timeGetTime();
m_IsAccelerating = true;
D3DXVECTOR3 normalVec( 0, 0, 0 );
D3DXVECTOR3 viewDirection( GetViewDirection() );
Physics::GetNormalVector( &viewDirection, &normalVec );
// 조심해!
// 가속도 가중치 하드 코딩 수정 할 것
m_Acceleration += ( viewDirection * 1.0f );
}
//--------------------------------------------------------------------------------------
// Updates the known and suspected threats for the soldier.
// Param1: The time in seconds passed since the last frame.
// Returns the current state of the action.
//--------------------------------------------------------------------------------------
BehaviourStatus Soldier::UpdateThreats(float deltaTime)
{
m_sensors.CheckForThreats(GetViewDirection(), m_soldierProperties.m_viewingDistance, m_soldierProperties.m_fieldOfView);
return StatusSuccess;
}
FSceneView::FSceneView(const FSceneViewInitOptions& InitOptions)
: Family(InitOptions.ViewFamily)
, State(InitOptions.SceneViewStateInterface)
, ViewActor(InitOptions.ViewActor)
, Drawer(InitOptions.ViewElementDrawer)
, ViewRect(InitOptions.GetConstrainedViewRect())
, UnscaledViewRect(InitOptions.GetConstrainedViewRect())
, UnconstrainedViewRect(InitOptions.GetViewRect())
, MaxShadowCascades(10)
, WorldToMetersScale(InitOptions.WorldToMetersScale)
, ProjectionMatrixUnadjustedForRHI(InitOptions.ProjectionMatrix)
, BackgroundColor(InitOptions.BackgroundColor)
, OverlayColor(InitOptions.OverlayColor)
, ColorScale(InitOptions.ColorScale)
, StereoPass(InitOptions.StereoPass)
, DiffuseOverrideParameter(FVector4(0,0,0,1))
, SpecularOverrideParameter(FVector4(0,0,0,1))
, NormalOverrideParameter(FVector4(0,0,0,1))
, RoughnessOverrideParameter(FVector2D(0,1))
, HiddenPrimitives(InitOptions.HiddenPrimitives)
, LODDistanceFactor(InitOptions.LODDistanceFactor)
, bCameraCut(InitOptions.bInCameraCut)
, bOriginOffsetThisFrame(InitOptions.bOriginOffsetThisFrame)
, CursorPos(InitOptions.CursorPos)
, bIsGameView(false)
, bForceShowMaterials(false)
, bIsViewInfo(false)
, bIsSceneCapture(false)
, bIsReflectionCapture(false)
, bIsLocked(false)
, bStaticSceneOnly(false)
#if WITH_EDITOR
, OverrideLODViewOrigin(InitOptions.OverrideLODViewOrigin)
, bAllowTranslucentPrimitivesInHitProxy( true )
, bHasSelectedComponents( false )
#endif
, FeatureLevel(InitOptions.ViewFamily ? InitOptions.ViewFamily->GetFeatureLevel() : GMaxRHIFeatureLevel)
{
check(UnscaledViewRect.Min.X >= 0);
check(UnscaledViewRect.Min.Y >= 0);
check(UnscaledViewRect.Width() > 0);
check(UnscaledViewRect.Height() > 0);
ViewMatrices.ViewMatrix = InitOptions.ViewMatrix;
// Adjust the projection matrix for the current RHI.
ViewMatrices.ProjMatrix = AdjustProjectionMatrixForRHI(ProjectionMatrixUnadjustedForRHI);
// Compute the view projection matrix and its inverse.
ViewProjectionMatrix = ViewMatrices.GetViewProjMatrix();
// For precision reasons the view matrix inverse is calculated independently.
InvViewMatrix = ViewMatrices.ViewMatrix.Inverse();
InvViewProjectionMatrix = ViewMatrices.GetInvProjMatrix() * InvViewMatrix;
bool ApplyPreViewTranslation = true;
// Calculate the view origin from the view/projection matrices.
if(IsPerspectiveProjection())
{
ViewMatrices.ViewOrigin = InvViewMatrix.GetOrigin();
}
#if WITH_EDITOR
else if (InitOptions.bUseFauxOrthoViewPos)
{
float DistanceToViewOrigin = WORLD_MAX;
ViewMatrices.ViewOrigin = FVector4(InvViewMatrix.TransformVector(FVector(0,0,-1)).GetSafeNormal()*DistanceToViewOrigin,1) + InvViewMatrix.GetOrigin();
}
#endif
else
{
ViewMatrices.ViewOrigin = FVector4(InvViewMatrix.TransformVector(FVector(0,0,-1)).GetSafeNormal(),0);
// to avoid issues with view dependent effect (e.g. Frensel)
ApplyPreViewTranslation = false;
}
// Translate world-space so its origin is at ViewOrigin for improved precision.
// Note that this isn't exactly right for orthogonal projections (See the above special case), but we still use ViewOrigin
// in that case so the same value may be used in shaders for both the world-space translation and the camera's world position.
if(ApplyPreViewTranslation)
{
ViewMatrices.PreViewTranslation = -FVector(ViewMatrices.ViewOrigin);
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
{
// console variable override
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.PreViewTranslation"));
int32 Value = CVar->GetValueOnGameThread();
static FVector PreViewTranslationBackup;
if(Value)
{
PreViewTranslationBackup = ViewMatrices.PreViewTranslation;
}
else
{
ViewMatrices.PreViewTranslation = PreViewTranslationBackup;
}
}
#endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
}
/** The view transform, starting from world-space points translated by -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();
// Compute screen scale factors.
// Stereo renders at half horizontal resolution, but compute shadow resolution based on full resolution.
const bool bStereo = StereoPass != eSSP_FULL;
const float ScreenXScale = bStereo ? 2.0f : 1.0f;
ViewMatrices.ProjectionScale.X = ScreenXScale * FMath::Abs(ViewMatrices.ProjMatrix.M[0][0]);
ViewMatrices.ProjectionScale.Y = FMath::Abs(ViewMatrices.ProjMatrix.M[1][1]);
ViewMatrices.ScreenScale = FMath::Max(
ViewRect.Size().X * 0.5f * ViewMatrices.ProjectionScale.X,
ViewRect.Size().Y * 0.5f * ViewMatrices.ProjectionScale.Y
);
ShadowViewMatrices = ViewMatrices;
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
{
// console variable override
int32 Value = CVarShadowFreezeCamera.GetValueOnAnyThread();
static FViewMatrices Backup = ShadowViewMatrices;
if(Value)
{
ShadowViewMatrices = Backup;
}
else
{
Backup = ShadowViewMatrices;
}
}
#endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
if (InitOptions.OverrideFarClippingPlaneDistance > 0.0f)
{
const FPlane FarPlane(ViewMatrices.ViewOrigin + GetViewDirection() * InitOptions.OverrideFarClippingPlaneDistance, GetViewDirection());
// Derive the view frustum from the view projection matrix, overriding the far plane
GetViewFrustumBounds(ViewFrustum,ViewProjectionMatrix,FarPlane,true,false);
}
else
{
// Derive the view frustum from the view projection matrix.
GetViewFrustumBounds(ViewFrustum,ViewProjectionMatrix,false);
}
// Derive the view's near clipping distance and plane.
// The GetFrustumFarPlane() is the near plane because of reverse Z projection.
bHasNearClippingPlane = ViewProjectionMatrix.GetFrustumFarPlane(NearClippingPlane);
if(ViewMatrices.ProjMatrix.M[2][3] > DELTA)
{
// Infinite projection with reversed Z.
NearClippingDistance = ViewMatrices.ProjMatrix.M[3][2];
}
else
{
// Ortho projection with reversed Z.
NearClippingDistance = (1.0f - ViewMatrices.ProjMatrix.M[3][2]) / ViewMatrices.ProjMatrix.M[2][2];
}
// Determine whether the view should reverse the cull mode due to a negative determinant. Only do this for a valid scene
bReverseCulling = (Family && Family->Scene) ? FMath::IsNegativeFloat(ViewMatrices.ViewMatrix.Determinant()) : false;
// OpenGL Gamma space output in GLSL flips Y when rendering directly to the back buffer (so not needed on PC, as we never render directly into the back buffer)
auto ShaderPlatform = GShaderPlatformForFeatureLevel[FeatureLevel];
static bool bPlatformRequiresReverseCulling = (IsOpenGLPlatform(ShaderPlatform) && !IsPCPlatform(ShaderPlatform));
static auto* MobileHDRCvar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.MobileHDR"));
check(MobileHDRCvar);
bReverseCulling = (bPlatformRequiresReverseCulling && MobileHDRCvar->GetValueOnAnyThread() == 0) ? !bReverseCulling : bReverseCulling;
// Setup transformation constants to be used by the graphics hardware to transform device normalized depth samples
// into world oriented z.
InvDeviceZToWorldZTransform = CreateInvDeviceZToWorldZTransform(ProjectionMatrixUnadjustedForRHI);
static TConsoleVariableData<int32>* SortPolicyCvar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.TranslucentSortPolicy"));
TranslucentSortPolicy = static_cast<ETranslucentSortPolicy::Type>(SortPolicyCvar->GetValueOnAnyThread());
TranslucentSortAxis = GetDefault<URendererSettings>()->TranslucentSortAxis;
// As the world is only accessable from the game thread, bIsGameView should be explicitly
// set on any other thread.
if(IsInGameThread())
{
bIsGameView = (Family && Family->Scene && Family->Scene->GetWorld() ) ? Family->Scene->GetWorld()->IsGameWorld() : false;
}
#if WITH_EDITOR
EditorViewBitflag = InitOptions.EditorViewBitflag;
SelectionOutlineColor = GEngine->GetSelectionOutlineColor();
#endif
}