public void AddOptionalFields()
{
foreach (var screen in Screens)
{
if (screen.orientations == null || screen.orientations.Length == 0)
{
screen.orientations = new[]
{
new OrientationData {
orientation = ScreenOrientation.Portrait
},
new OrientationData {
orientation = ScreenOrientation.PortraitUpsideDown
},
new OrientationData {
orientation = ScreenOrientation.LandscapeLeft
},
new OrientationData {
orientation = ScreenOrientation.LandscapeRight
}
};
}
foreach (var orientation in screen.orientations)
{
if (orientation.safeArea == Rect.zero)
{
orientation.safeArea = SimulatorUtilities.IsLandscape(orientation.orientation) ? new Rect(0, 0, screen.height, screen.width) : new Rect(0, 0, screen.width, screen.height);
}
}
}
}
private Quaternion ComputeRotationForHighlightSafeArea()
{
var rotation = Quaternion.identity;
// We have to consider the case that the rendering orientation is not same as the physical orientation.
var physicalOrientation = SimulatorUtilities.RotationToScreenOrientation(m_Rotation);
switch (TargetOrientation)
{
case ScreenOrientation.Portrait:
case ScreenOrientation.PortraitUpsideDown:
if (SimulatorUtilities.IsLandscape(physicalOrientation))
{
rotation = Quaternion.Euler(0, 0, 90);
}
break;
case ScreenOrientation.LandscapeLeft:
case ScreenOrientation.LandscapeRight:
if (!SimulatorUtilities.IsLandscape(physicalOrientation))
{
rotation = Quaternion.Euler(0, 0, 90);
}
break;
}
return(rotation);
}
private void DrawPreviewImage(MeshGenerationContext mgc)
{
if (m_PreviewImage == null)
{
return;
}
ComputePreviewImageHalfSizeAndOffset(out Vector2 halfSize, out Vector2 offset);
var meshWriteData = mgc.Allocate(4, 6, m_PreviewImage, m_PreviewMaterial, MeshGenerationContext.MeshFlags.None);
var vertices = new Vertex[4];
vertices[0].position = new Vector3(-halfSize.x, -halfSize.y, Vertex.nearZ);
vertices[0].tint = Color.white;
vertices[1].position = new Vector3(halfSize.x, -halfSize.y, Vertex.nearZ);
vertices[1].tint = Color.white;
vertices[2].position = new Vector3(halfSize.x, halfSize.y, Vertex.nearZ);
vertices[2].tint = Color.white;
vertices[3].position = new Vector3(-halfSize.x, halfSize.y, Vertex.nearZ);
vertices[3].tint = Color.white;
SimulatorUtilities.SetTextureCoordinates(TargetOrientation, vertices);
SimulatorUtilities.TransformVertices(m_Rotation, offset, vertices);
meshWriteData.SetAllVertices(vertices);
var indices = new ushort[] { 0, 3, 1, 1, 3, 2 };
meshWriteData.SetAllIndices(indices);
}
private void RenderPreviewImage()
{
if (PreviewTexture == null)
{
return;
}
ComputePreviewImageHalfSizeAndOffset(out Vector2 halfSize, out Vector2 offset);
var vertices = new Vector3[4];
vertices[0] = new Vector3(-halfSize.x, -halfSize.y, zValue);
vertices[1] = new Vector3(halfSize.x, -halfSize.y, zValue);
vertices[2] = new Vector3(halfSize.x, halfSize.y, zValue);
vertices[3] = new Vector3(-halfSize.x, halfSize.y, zValue);
var uvs = new Vector2[4];
SimulatorUtilities.SetTextureCoordinates(TargetOrientation, uvs);
var mesh = new Mesh()
{
vertices = vertices,
uv = uvs,
triangles = new[] { 0, 1, 3, 1, 2, 3 }
};
m_PreviewMaterial.mainTexture = PreviewTexture;
m_PreviewMaterial.SetPass(0);
var transformMatrix = Matrix4x4.TRS(new Vector3(offset.x, offset.y), m_Rotation, Vector3.one);
Graphics.DrawMeshNow(mesh, transformMatrix);
}
private void DrawHighlightSafeArea(MeshGenerationContext mgc)
{
if (!m_HighlightSafeArea)
{
return;
}
var safeAreaInScreen = GetSafeAreaInScreen();
var halfImageWidth = safeAreaInScreen.width / 2;
var halfImageHeight = safeAreaInScreen.height / 2;
const int vertexCount = 8, indexCount = 24;
var meshWriteData = mgc.Allocate(vertexCount, indexCount);
var vertices = new Vertex[vertexCount];
var highlightColor = Color.green;
const int highlightLineWidth = 2;
vertices[0].position = new Vector3(-halfImageWidth, -halfImageHeight, Vertex.nearZ);
vertices[0].tint = highlightColor;
vertices[1].position = new Vector3(halfImageWidth, -halfImageHeight, Vertex.nearZ);
vertices[1].tint = highlightColor;
vertices[2].position = new Vector3(halfImageWidth, halfImageHeight, Vertex.nearZ);
vertices[2].tint = highlightColor;
vertices[3].position = new Vector3(-halfImageWidth, halfImageHeight, Vertex.nearZ);
vertices[3].tint = highlightColor;
vertices[4].position = new Vector3(-halfImageWidth + highlightLineWidth, -halfImageHeight + highlightLineWidth, Vertex.nearZ);
vertices[4].tint = highlightColor;
vertices[5].position = new Vector3(halfImageWidth - highlightLineWidth, -halfImageHeight + highlightLineWidth, Vertex.nearZ);
vertices[5].tint = highlightColor;
vertices[6].position = new Vector3(halfImageWidth - highlightLineWidth, halfImageHeight - highlightLineWidth, Vertex.nearZ);
vertices[6].tint = highlightColor;
vertices[7].position = new Vector3(-halfImageWidth + highlightLineWidth, halfImageHeight - highlightLineWidth, Vertex.nearZ);
vertices[7].tint = highlightColor;
var offset = new Vector2(m_Offset.x + safeAreaInScreen.x / 2, m_Offset.y + safeAreaInScreen.y / 2);
offset = ComputeOffsetForScreenMode(offset, true);
SimulatorUtilities.TransformVertices(ComputeRotationForHighlightSafeArea(), offset, vertices);
meshWriteData.SetAllVertices(vertices);
var indices = new ushort[]
{
0, 4, 1, 1, 4, 5, 1, 5, 6, 1, 6, 2, 6, 7, 2, 7, 3, 2, 0, 3, 4, 3, 7, 4
};
meshWriteData.SetAllIndices(indices);
}
private void Rotate(Quaternion rotation)
{
if (m_AutoRotation)
{
var newOrientation = SimulatorUtilities.RotationToScreenOrientation(rotation);
if (m_Screen.orientations.ContainsKey(newOrientation) && m_AllowedAutoRotation[newOrientation])
{
ForceNewOrientation(newOrientation);
}
OnOrientationChanged?.Invoke(m_AutoRotation);
}
}
private void DrawDeviceImage(MeshGenerationContext mgc)
{
if (m_DeviceInfo.Meta.overlayImage == null)
{
DrawDeviceBorder(mgc);
return;
}
var scale = m_Scale / 100f;
var halfImageWidth = scale * m_DeviceInfo.Screens[0].width / 2;
var halfImageHeight = scale * m_DeviceInfo.Screens[0].height / 2;
var leftWidth = halfImageWidth + scale * m_DeviceInfo.Meta.overlayOffset.x;
var topWidth = halfImageHeight + scale * m_DeviceInfo.Meta.overlayOffset.y;
var rightWidth = halfImageWidth + scale * m_DeviceInfo.Meta.overlayOffset.z;
var bottomWidth = halfImageHeight + scale * m_DeviceInfo.Meta.overlayOffset.w;
var meshWriteData = mgc.Allocate(4, 6, m_DeviceInfo.Meta.overlayImage);
var vertices = new Vertex[4];
vertices[0].position = new Vector3(-leftWidth, -topWidth, Vertex.nearZ);
vertices[0].tint = Color.white;
vertices[0].uv = new Vector2(0, 1);
vertices[1].position = new Vector3(rightWidth, -topWidth, Vertex.nearZ);
vertices[1].tint = Color.white;
vertices[1].uv = new Vector2(1, 1);
vertices[2].position = new Vector3(rightWidth, bottomWidth, Vertex.nearZ);
vertices[2].tint = Color.white;
vertices[2].uv = new Vector2(1, 0);
vertices[3].position = new Vector3(-leftWidth, bottomWidth, Vertex.nearZ);
vertices[3].tint = Color.white;
vertices[3].uv = new Vector2(0, 0);
SimulatorUtilities.TransformVertices(m_Rotation, m_Offset, vertices);
meshWriteData.SetAllVertices(vertices);
var indices = new ushort[] { 0, 3, 1, 1, 3, 2 };
meshWriteData.SetAllIndices(indices);
}
private void Rotate(Quaternion rotation)
{
if (!m_AutoRotation)
{
return;
}
var newOrientation = SimulatorUtilities.RotationToScreenOrientation(rotation);
if (newOrientation != m_RenderedOrientation && m_SupportedOrientations.ContainsKey(newOrientation) && m_AllowedAutoRotation[newOrientation])
{
ForceNewOrientation(newOrientation);
}
else
{
OnOrientationChanged?.Invoke(m_AutoRotation);
}
}
private Rect GetSafeAreaInScreen()
{
var sa = m_DeviceInfo.Screens[0].orientations[TargetOrientation].safeArea;
if (!IsFullScreen)
{
if (SimulatorUtilities.IsLandscape(TargetOrientation))
{
sa.width -= m_DeviceInfo.Screens[0].navigationBarHeight;
}
else
{
sa.height -= m_DeviceInfo.Screens[0].navigationBarHeight;
}
}
var scale = m_Scale / 100f;
return(new Rect(0, 0, sa.width * scale, sa.height * scale));
}
public ScreenSimulation(DeviceInfo device, IInputProvider inputProvider, SimulationPlayerSettings playerSettings)
{
m_DeviceInfo = device;
m_Screen = device.Screens[0];
m_InputProvider = inputProvider;
m_InputProvider.OnRotation += Rotate;
m_SupportedOrientations = new Dictionary <ScreenOrientation, OrientationData>();
foreach (var o in m_Screen.orientations)
{
m_SupportedOrientations.Add(o.orientation, o);
}
m_AllowedAutoRotation = new Dictionary <ScreenOrientation, bool>();
m_AllowedAutoRotation.Add(ScreenOrientation.Portrait, playerSettings.allowedPortrait);
m_AllowedAutoRotation.Add(ScreenOrientation.PortraitUpsideDown, playerSettings.allowedPortraitUpsideDown);
m_AllowedAutoRotation.Add(ScreenOrientation.LandscapeLeft, playerSettings.allowedLandscapeLeft);
m_AllowedAutoRotation.Add(ScreenOrientation.LandscapeRight, playerSettings.allowedLandscapeRight);
// Set the full screen mode.
m_IsFullScreen = !m_DeviceInfo.IsAndroidDevice() || playerSettings.androidStartInFullscreen;
// Calculate the right orientation.
var settingOrientation = SimulatorUtilities.ToScreenOrientation(playerSettings.defaultOrientation);
if (settingOrientation == ScreenOrientation.AutoRotation)
{
m_AutoRotation = true;
var newOrientation = SimulatorUtilities.RotationToScreenOrientation(m_InputProvider.Rotation);
if (m_SupportedOrientations.ContainsKey(newOrientation) && m_AllowedAutoRotation[newOrientation])
{
ForceNewOrientation(newOrientation);
}
else
{
SetFirstAvailableAutoOrientation();
}
}
else if (m_SupportedOrientations.ContainsKey(settingOrientation))
{
m_AutoRotation = false;
ForceNewOrientation(settingOrientation);
}
else
{
// At least iPhone X responds to this absolute corner case by crashing, we will not do that.
m_AutoRotation = false;
ForceNewOrientation(m_SupportedOrientations.Keys.ToArray()[0]);
}
// Calculate the right resolution.
var initWidth = m_Screen.width;
var initHeight = m_Screen.height;
if (playerSettings.resolutionScalingMode == ResolutionScalingMode.FixedDpi && playerSettings.targetDpi < m_Screen.dpi)
{
m_DpiRatio = playerSettings.targetDpi / m_Screen.dpi;
initWidth = (int)(initWidth * m_DpiRatio);
initHeight = (int)(initHeight * m_DpiRatio);
}
m_CurrentWidth = IsRenderingLandscape ? initHeight : initWidth;
m_CurrentHeight = IsRenderingLandscape ? initWidth : initHeight;
if (!m_IsFullScreen)
{
CalculateScreenResolutionForScreenMode(out m_CurrentWidth, out m_CurrentHeight);
CalculateInsets();
}
CalculateSafeAreaAndCutouts();
ShimManager.UseShim(this);
}
private void ComputeBoundingBox()
{
var overlayOffset = m_DeviceInfo.Meta.overlayOffset;
var width = m_DeviceInfo.Screens[0].width + overlayOffset.x + overlayOffset.z;
var height = m_DeviceInfo.Screens[0].height + overlayOffset.y + overlayOffset.w;
var toScreenCenter = new Vector2(m_DeviceInfo.Screens[0].width / 2 + overlayOffset.x, m_DeviceInfo.Screens[0].height / 2 + overlayOffset.y);
var vertices = new Vector3[4];
vertices[0] = new Vector3(0, 0, Vertex.nearZ);
vertices[1] = new Vector3(width, 0, Vertex.nearZ);
vertices[2] = new Vector3(width, height, Vertex.nearZ);
vertices[3] = new Vector3(0, height, Vertex.nearZ);
var scale = m_Scale / 100f;
Matrix4x4 transformMatrix = Matrix4x4.TRS(
new Vector3(0, 0, 0), m_Rotation, new Vector3(scale, scale));
for (int index = 0; index < vertices.Length; ++index)
{
vertices[index] = transformMatrix.MultiplyPoint(vertices[index]);
}
var min = new Vector2(float.MaxValue, float.MaxValue);
var max = new Vector2(float.MinValue, float.MinValue);
foreach (var vertex in vertices)
{
if (vertex.x < min.x)
{
min.x = vertex.x;
}
if (vertex.x > max.x)
{
max.x = vertex.x;
}
if (vertex.y < min.y)
{
min.y = vertex.y;
}
if (vertex.y > max.y)
{
max.y = vertex.y;
}
}
m_BoundingBox = max - min;
m_Offset = m_BoundingBox / 2;
// We need to consider the case that overlay offset is not symmetrical.
var physicalOrientation = SimulatorUtilities.RotationToScreenOrientation(m_Rotation);
switch (physicalOrientation)
{
case ScreenOrientation.Portrait:
m_Offset.x -= (overlayOffset.z - overlayOffset.x) * scale / 2;
m_Offset.y -= (overlayOffset.w - overlayOffset.y) * scale / 2;
break;
case ScreenOrientation.PortraitUpsideDown:
m_Offset.x += (overlayOffset.z - overlayOffset.x) * scale / 2;
m_Offset.y += (overlayOffset.w - overlayOffset.y) * scale / 2;
break;
case ScreenOrientation.Landscape:
m_Offset.x -= (overlayOffset.w - overlayOffset.y) * scale / 2;
m_Offset.y += (overlayOffset.z - overlayOffset.x) * scale / 2;
break;
case ScreenOrientation.LandscapeRight:
m_Offset.x += (overlayOffset.w - overlayOffset.y) * scale / 2;
m_Offset.y -= (overlayOffset.z - overlayOffset.x) * scale / 2;
break;
}
// Device space: (0,0) at the left top corner of the device in portrait orientation, 1 unit is 1 screen pixel of the device screen
var deviceSpaceToPreviewImageRendererSpace =
Matrix4x4.TRS(new Vector3(m_Offset.x, m_Offset.y), m_Rotation, new Vector3(scale, scale, 1)) *
Matrix4x4.Translate(new Vector3(-toScreenCenter.x, -toScreenCenter.y, 0));
var deviceSpaceToScreenSpace = Matrix4x4.Translate(new Vector3(-overlayOffset.x, -overlayOffset.y));
m_TouchEventManipulator.PreviewImageRendererSpaceToScreenSpace = deviceSpaceToScreenSpace * deviceSpaceToPreviewImageRendererSpace.inverse;
m_PreviewImageRenderer.style.width = m_BoundingBox.x;
m_PreviewImageRenderer.style.height = m_BoundingBox.y;
}
private void DrawDeviceBorder(MeshGenerationContext mgc)
{
// For now, we draw device as borders. We can draw device image in the future.
var scale = m_Scale / 100f;
var halfImageWidth = scale * m_DeviceInfo.Screens[0].width / 2;
var halfImageHeight = scale * m_DeviceInfo.Screens[0].height / 2;
var leftOuterWidth = halfImageWidth + scale * m_DeviceInfo.Meta.overlayOffset.x;
var topOuterWidth = halfImageHeight + scale * m_DeviceInfo.Meta.overlayOffset.y;
var rightOuterWidth = halfImageWidth + scale * m_DeviceInfo.Meta.overlayOffset.z;
var bottomOuterWidth = halfImageHeight + scale * m_DeviceInfo.Meta.overlayOffset.w;
var padding = 20 * scale;
var leftInnerWidth = leftOuterWidth - padding;
var topInnerWidth = topOuterWidth - padding;
var rightInnerWidth = rightOuterWidth - padding;
var bottomInnerWidth = bottomOuterWidth - padding;
var outerColor = EditorGUIUtility.isProSkin ? new Color(217f / 255, 217f / 255, 217f / 255) : new Color(100f / 255, 100f / 255, 100f / 255);
var innerColor = new Color(41f / 255, 41f / 255, 41f / 255);
const int vertexCount = 16, indexCount = 48;
var meshWriteData = mgc.Allocate(vertexCount, indexCount);
var vertices = new Vertex[vertexCount];
// Outer border.
vertices[0].position = new Vector3(-leftOuterWidth, -topOuterWidth, Vertex.nearZ);
vertices[0].tint = outerColor;
vertices[1].position = new Vector3(rightOuterWidth, -topOuterWidth, Vertex.nearZ);
vertices[1].tint = outerColor;
vertices[2].position = new Vector3(rightOuterWidth, bottomOuterWidth, Vertex.nearZ);
vertices[2].tint = outerColor;
vertices[3].position = new Vector3(-leftOuterWidth, bottomOuterWidth, Vertex.nearZ);
vertices[3].tint = outerColor;
vertices[4].position = new Vector3(-leftInnerWidth, -topInnerWidth, Vertex.nearZ);
vertices[4].tint = outerColor;
vertices[5].position = new Vector3(rightInnerWidth, -topInnerWidth, Vertex.nearZ);
vertices[5].tint = outerColor;
vertices[6].position = new Vector3(rightInnerWidth, bottomInnerWidth, Vertex.nearZ);
vertices[6].tint = outerColor;
vertices[7].position = new Vector3(-leftInnerWidth, bottomInnerWidth, Vertex.nearZ);
vertices[7].tint = outerColor;
//Inner border.
vertices[8].position = vertices[4].position;
vertices[8].tint = innerColor;
vertices[9].position = vertices[5].position;
vertices[9].tint = innerColor;
vertices[10].position = vertices[6].position;
vertices[10].tint = innerColor;
vertices[11].position = vertices[7].position;
vertices[11].tint = innerColor;
vertices[12].position = new Vector3(-halfImageWidth, -halfImageHeight, Vertex.nearZ);
vertices[12].tint = innerColor;
vertices[13].position = new Vector3(halfImageWidth, -halfImageHeight, Vertex.nearZ);
vertices[13].tint = innerColor;
vertices[14].position = new Vector3(halfImageWidth, halfImageHeight, Vertex.nearZ);
vertices[14].tint = innerColor;
vertices[15].position = new Vector3(-halfImageWidth, halfImageHeight, Vertex.nearZ);
vertices[15].tint = innerColor;
SimulatorUtilities.TransformVertices(m_Rotation, m_Offset, vertices);
meshWriteData.SetAllVertices(vertices);
var indices = new ushort[]
{
0, 4, 1, 1, 4, 5, 1, 5, 6, 1, 6, 2, 6, 7, 2, 7, 3, 2, 0, 3, 4, 3, 7, 4, // Outer
8, 12, 9, 9, 12, 13, 9, 13, 14, 9, 14, 10, 14, 15, 10, 15, 11, 10, 8, 11, 12, 11, 15, 12 // Inner
};
meshWriteData.SetAllIndices(indices);
}
private Vector2 ComputeOffsetForScreenMode(Vector2 offset, bool isHighlightingSafeArea = false)
{
// If we're rendering the preview image in full screen mode, no extra offset.
if (IsFullScreen && !isHighlightingSafeArea)
{
return(offset);
}
var scale = m_Scale / 100f;
var scaledNavigationBarOffset = (IsFullScreen && isHighlightingSafeArea) ? 0 : m_DeviceInfo.Screens[0].navigationBarHeight * scale / 2.0f;
var safeArea = m_DeviceInfo.Screens[0].orientations[TargetOrientation].safeArea;
var safeAreaOffset = new Vector2(safeArea.x + safeArea.width / 2.0f, safeArea.y + safeArea.height / 2.0f);
if (SimulatorUtilities.IsLandscape(TargetOrientation))
{
safeAreaOffset.x -= m_DeviceInfo.Screens[0].height / 2.0f;
safeAreaOffset.y -= m_DeviceInfo.Screens[0].width / 2.0f;
}
else
{
safeAreaOffset.x -= m_DeviceInfo.Screens[0].width / 2.0f;
safeAreaOffset.y -= m_DeviceInfo.Screens[0].height / 2.0f;
}
var scaledSafeAreaOffset = scale * safeAreaOffset;
var tempOffset = offset;
// We have to consider the case that the rendering orientation is not same as the physical orientation.
var physicalOrientation = SimulatorUtilities.RotationToScreenOrientation(m_Rotation);
switch (TargetOrientation)
{
case ScreenOrientation.Portrait:
switch (physicalOrientation)
{
case ScreenOrientation.Portrait:
tempOffset.x = tempOffset.x + scaledSafeAreaOffset.x;
tempOffset.y = tempOffset.y - scaledSafeAreaOffset.y - scaledNavigationBarOffset;
break;
case ScreenOrientation.PortraitUpsideDown:
tempOffset.x = tempOffset.x + scaledSafeAreaOffset.x;
tempOffset.y = tempOffset.y + scaledSafeAreaOffset.y + scaledNavigationBarOffset;
break;
case ScreenOrientation.LandscapeLeft:
tempOffset.x = tempOffset.x - scaledSafeAreaOffset.y - scaledNavigationBarOffset;
tempOffset.y = tempOffset.y + scaledSafeAreaOffset.x;
break;
case ScreenOrientation.LandscapeRight:
tempOffset.x = tempOffset.x + scaledSafeAreaOffset.y + scaledNavigationBarOffset;
tempOffset.y = tempOffset.y + scaledSafeAreaOffset.x;
break;
}
break;
case ScreenOrientation.PortraitUpsideDown:
switch (physicalOrientation)
{
case ScreenOrientation.Portrait:
tempOffset.x = tempOffset.x + scaledSafeAreaOffset.x;
tempOffset.y = tempOffset.y + scaledSafeAreaOffset.y + scaledNavigationBarOffset;
break;
case ScreenOrientation.PortraitUpsideDown:
tempOffset.x = tempOffset.x + scaledSafeAreaOffset.x;
tempOffset.y = tempOffset.y - scaledSafeAreaOffset.y - scaledNavigationBarOffset;
break;
case ScreenOrientation.LandscapeLeft:
tempOffset.x = tempOffset.x + scaledSafeAreaOffset.y + scaledNavigationBarOffset;
tempOffset.y = tempOffset.y + scaledSafeAreaOffset.x;
break;
case ScreenOrientation.LandscapeRight:
tempOffset.x = tempOffset.x - scaledSafeAreaOffset.y - scaledNavigationBarOffset;
tempOffset.y = tempOffset.y + scaledSafeAreaOffset.x;
break;
}
break;
case ScreenOrientation.LandscapeLeft:
switch (physicalOrientation)
{
case ScreenOrientation.Portrait:
tempOffset.x = tempOffset.x + scaledSafeAreaOffset.y;
tempOffset.y = tempOffset.y + scaledSafeAreaOffset.x - scaledNavigationBarOffset;
break;
case ScreenOrientation.PortraitUpsideDown:
tempOffset.x = tempOffset.x - scaledSafeAreaOffset.y;
tempOffset.y = tempOffset.y - scaledSafeAreaOffset.x + scaledNavigationBarOffset;
break;
case ScreenOrientation.LandscapeLeft:
tempOffset.x = tempOffset.x + scaledSafeAreaOffset.x - scaledNavigationBarOffset;
tempOffset.y = tempOffset.y - scaledSafeAreaOffset.y;
break;
case ScreenOrientation.LandscapeRight:
tempOffset.x = tempOffset.x - scaledSafeAreaOffset.x + scaledNavigationBarOffset;
tempOffset.y = tempOffset.y + scaledSafeAreaOffset.y;
break;
}
break;
case ScreenOrientation.LandscapeRight:
switch (physicalOrientation)
{
case ScreenOrientation.Portrait:
tempOffset.x = tempOffset.x - scaledSafeAreaOffset.y;
tempOffset.y = tempOffset.y - scaledSafeAreaOffset.x - scaledNavigationBarOffset;
break;
case ScreenOrientation.PortraitUpsideDown:
tempOffset.x = tempOffset.x + scaledSafeAreaOffset.y;
tempOffset.y = tempOffset.y + scaledSafeAreaOffset.x + scaledNavigationBarOffset;
break;
case ScreenOrientation.LandscapeLeft:
tempOffset.x = tempOffset.x - scaledSafeAreaOffset.x - scaledNavigationBarOffset;
tempOffset.y = tempOffset.y + scaledSafeAreaOffset.y;
break;
case ScreenOrientation.LandscapeRight:
tempOffset.x = tempOffset.x + scaledSafeAreaOffset.x + scaledNavigationBarOffset;
tempOffset.y = tempOffset.y - scaledSafeAreaOffset.y;
break;
}
break;
}
return(tempOffset);
}
private bool ShouldShim()
{
return(SimulatorUtilities.ShouldShim(m_ShimmedAssemblies));
}