private void DrawSizeStats()
{
PixelPerfectCameraCustome myCamera = (PixelPerfectCameraCustome)target;
EditorGUI.BeginDisabledGroup(true);
// Size
{
GUIStyle style = new GUIStyle(GUI.skin.label);
style.richText = true;
string width = string.Format("{0:0.00}", myCamera.cameraSize.x);
string height = string.Format("{0:0.00}", myCamera.cameraSize.y);
if (myCamera.contraintUsed == PixelPerfectCameraCustome.ConstraintType.Horizontal)
{
width = makeBold(width);
}
else if (myCamera.contraintUsed == PixelPerfectCameraCustome.ConstraintType.Vertical)
{
height = makeBold(height);
}
EditorGUILayout.LabelField("Size", string.Format("{0} x {1}", width, height), style);
}
// Pixels Per Unit
{
string ppuString = string.Format("{0:0.00}", myCamera.cameraPixelsPerUnit);
string tooltipString = "The number of screen pixels a unit is rendered to.";
EditorGUILayout.LabelField(new GUIContent("Pixels Per Unit", tooltipString), new GUIContent(ppuString));
}
// Ratio
{
string ratioFormat = (myCamera.pixelPerfect) ? "{0:0}" : "{0:0.0000}";
string pixelsString = string.Format(ratioFormat + "x [{1:0.00} x {2:0.00}]", myCamera.ratio, myCamera.nativeAssetResolution.x, myCamera.nativeAssetResolution.y);
string tooltipString = "The screen resolution as a multiple of 2 numbers. The first is the number of screen pixels an asset pixel will render to. The second is the camera resolution in asset pixels.";
EditorGUILayout.LabelField(new GUIContent("Pixels", tooltipString), new GUIContent(pixelsString));
}
// Target Coverage
{
string percentageUsed = string.Format("{0:P2}", myCamera.fovCoverage);
string tooltipString = "How much of the targeted camera size was covered.";
EditorGUILayout.LabelField(new GUIContent("Coverage", tooltipString), new GUIContent(percentageUsed));
}
EditorGUI.EndDisabledGroup();
}
void Initialize(bool warn)
{
#if UNITY_EDITOR
if (!gameObject.activeInHierarchy)
{
return;
}
#endif
_canvas = GetComponent <Canvas> ();
if (_canvas.renderMode != RenderMode.WorldSpace)
{
Debug.Log("Render mode: " + _canvas.renderMode + " is not supported by CanvasWorldScaler");
return;
}
if (uiCamera == null)
{
if (warn)
{
Debug.Log("You have to assign a UI camera!");
}
return;
}
_pixelPerfectCamera = uiCamera.GetComponent <PixelPerfectCameraCustome> ();
if (_pixelPerfectCamera == null)
{
if (warn)
{
Debug.Log("You have to use the PixelPerfectCamera script on the assigned UI camera!");
}
return;
}
_isInitialized = true;
AdjustCanvas();
}
void OnWillRenderObject()
{
//Debug.Log("on will" + Camera.current);
Camera cam = Camera.current;
if (!cam)
{
return;
}
PixelPerfectCameraCustome pixelPerfectCamera = cam.GetComponent <PixelPerfectCameraCustome>();
bool retroSnap = (pixelPerfectCamera == null) ? false : pixelPerfectCamera.retroSnap;
#if !REDUCE_JITTER
if (!retroSnap)
{
return;
}
#endif
shouldRestorePosition = true;
actualPosition = transform.position;
float cameraPPU = (float)cam.pixelHeight / (2f * cam.orthographicSize);
float cameraUPP = 1.0f / cameraPPU;
Vector2 camPos = cam.transform.position.xy();
Vector2 pos = actualPosition.xy();
Vector2 relPos = pos - camPos;
Vector2 offset = new Vector2(0, 0);
// offset for screen pixel edge if screen size is odd
offset.x = (cam.pixelWidth % 2 == 0) ? 0 : 0.5f;
offset.y = (cam.pixelHeight % 2 == 0) ? 0 : 0.5f;
// offset for pivot in Sprites
Vector2 pivotOffsetInt = new Vector2(0, 0);
Vector2 pivotOffsetFrac = new Vector2(0, 0);
if (sprite != null)
{
Vector2 pivotOffset = sprite.pivot - new Vector2(Mathf.Floor(sprite.pivot.x), Mathf.Floor(sprite.pivot.y)); // the fractional part in texture pixels
if (retroSnap)
{
pivotOffsetFrac = pivotOffset;
}
else
{
float camPixelsPerAssetPixel = cameraPPU / sprite.pixelsPerUnit;
pivotOffset *= camPixelsPerAssetPixel; // in screen pixels
pivotOffsetFrac = pivotOffset - new Vector2(Mathf.Floor(pivotOffset.x), (Mathf.Floor(pivotOffset.y))); // fract part in screen pixels
pivotOffsetInt = pivotOffset - pivotOffsetFrac; // integer part in screen pixels
// We subtract the integer part so that the anchor point snaps to the texel's edge
}
}
if (retroSnap)
{
float assetPPU = pixelPerfectCamera.assetsPixelsPerUnit;
float assetUPP = 1.0f / assetPPU;
float camPixelsPerAssetPixel = cameraPPU / assetPPU;
offset.x /= camPixelsPerAssetPixel; // zero or half a screen pixel in texture pixels
offset.y /= camPixelsPerAssetPixel;
relPos.x = (Mathf.Round(relPos.x / assetUPP - offset.x - pivotOffsetFrac.x) + offset.x + pivotOffsetFrac.x) * assetUPP;
relPos.y = (Mathf.Round(relPos.y / assetUPP - offset.y - pivotOffsetFrac.y) + offset.y + pivotOffsetFrac.y) * assetUPP;
}
else
{
// Convert the units to pixels, round them, convert back to units. The offsets make sure that the distance we round is from screen pixel (fragment) edges to texel edges.
relPos.x = (Mathf.Round(relPos.x / cameraUPP - offset.x - pivotOffsetFrac.x) + offset.x + pivotOffsetFrac.x + pivotOffsetInt.x) * cameraUPP;
relPos.y = (Mathf.Round(relPos.y / cameraUPP - offset.y - pivotOffsetFrac.y) + offset.y + pivotOffsetFrac.y + pivotOffsetInt.y) * cameraUPP;
}
pos = relPos + camPos;
transform.position = new Vector3(pos.x, pos.y, actualPosition.z);
}
