HX-PGS-ERP-SYS
/
HX-PGS-AIM-Android
Observar 4
Favorito 0
Fork 0
Código Issues 0 Pull requests 0 Versões 0 Wiki Atividade
Nenhuma descrição
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
1 Commit
1 Branch
Branch: master
Branches Tags
${ item.name }
Criar branch ${ searchTerm }
de master
${ noResults }
HX-PGS-AIM-Android/Library/PackageCache/com.unity.render-pipelines..../Tests/Runtime/PixelPerfectCameraTests.cs

PixelPerfectCameraTests.cs 14KB
Link permanente Histórico Original

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326 
  1. using NUnit.Framework;

  2. using UnityEngine.Rendering.Universal;

  3. 

  4. namespace UnityEngine.Rendering.Universal.Tests

  5. {

  6.     internal class PixelPerfectCameraTests

  7.     {

  8.         internal class PixelPerfectCameraTestComponent : IPixelPerfectCamera

  9.         {

  10.             public int assetsPPU { get; set; }

  11.             public int refResolutionX { get; set; }

  12.             public int refResolutionY { get; set; }

  13.             public bool upscaleRT { get; set; }

  14.             public bool pixelSnapping { get; set; }

  15.             public bool cropFrameX { get; set; }

  16.             public bool cropFrameY { get; set; }

  17.             public bool stretchFill { get; set; }

  18.         }

  19. 

  20.         internal class CalculateCameraPropertiesResult

  21.         {

  22.             public int zoom;

  23.             public bool useOffscreenRT;

  24.             public int offscreenRTWidth;

  25.             public int offscreenRTHeight;

  26.             public Rect pixelRect;

  27.             public float orthoSize;

  28.             public float unitsPerPixel;

  29.         }

  30. 

  31.         [UnityEngine.Scripting.Preserve]

  32.         private static object[] GetCalculateCameraPropertiesTestCases()

  33.         {

  34.             object[] testCaseArray = new object[9];

  35. 

  36.             for (int i = 0; i < testCaseArray.Length; ++i)

  37.             {

  38.                 PixelPerfectCameraTestComponent testComponent = new PixelPerfectCameraTestComponent();

  39.                 int screenWidth = 0;

  40.                 int screenHeight = 0;

  41.                 CalculateCameraPropertiesResult expected = new CalculateCameraPropertiesResult();

  42. 

  43.                 switch (i)

  44.                 {

  45.                     case 0:

  46.                         testComponent.assetsPPU = 100;

  47.                         testComponent.refResolutionX = 400;

  48.                         testComponent.refResolutionY = 300;

  49.                         testComponent.upscaleRT = false;

  50.                         testComponent.pixelSnapping = true;

  51.                         testComponent.cropFrameX = true;

  52.                         testComponent.cropFrameY = true;

  53.                         testComponent.stretchFill = true;

  54.                         screenWidth = 800;

  55.                         screenHeight = 500;

  56. 

  57.                         expected.zoom = 1;

  58.                         expected.useOffscreenRT = true;

  59.                         expected.offscreenRTWidth = 400;

  60.                         expected.offscreenRTHeight = 300;

  61.                         expected.pixelRect = new Rect(0.0f, 0.0f, 400, 300);

  62.                         expected.orthoSize = 1.5f;

  63.                         expected.unitsPerPixel = 0.01f;

  64.                         break;

  65. 

  66.                     case 1:

  67.                         testComponent.assetsPPU = 100;

  68.                         testComponent.refResolutionX = 400;

  69.                         testComponent.refResolutionY = 300;

  70.                         testComponent.upscaleRT = true;

  71.                         testComponent.pixelSnapping = true;

  72.                         testComponent.cropFrameX = true;

  73.                         testComponent.cropFrameY = true;

  74.                         testComponent.stretchFill = true;

  75.                         screenWidth = 1100;

  76.                         screenHeight = 900;

  77. 

  78.                         expected.zoom = 2;

  79.                         expected.useOffscreenRT = true;

  80.                         expected.offscreenRTWidth = 400;

  81.                         expected.offscreenRTHeight = 300;

  82.                         expected.pixelRect = new Rect(0.0f, 0.0f, 400, 300);

  83.                         expected.orthoSize = 1.5f;

  84.                         expected.unitsPerPixel = 0.01f;

  85.                         break;

  86. 

  87.                     case 2:

  88.                         testComponent.assetsPPU = 100;

  89.                         testComponent.refResolutionX = 400;

  90.                         testComponent.refResolutionY = 300;

  91.                         testComponent.upscaleRT = true;

  92.                         testComponent.pixelSnapping = true;

  93.                         testComponent.cropFrameX = false;

  94.                         testComponent.cropFrameY = true;

  95.                         testComponent.stretchFill = false;

  96.                         screenWidth = 400;

  97.                         screenHeight = 250;

  98. 

  99.                         expected.zoom = 1;

  100.                         expected.useOffscreenRT = true;

  101.                         expected.offscreenRTWidth = 400;

  102.                         expected.offscreenRTHeight = 300;

  103.                         expected.pixelRect = new Rect(0.0f, 0.0f, 400, 300);

  104.                         expected.orthoSize = 1.5f;

  105.                         expected.unitsPerPixel = 0.01f;

  106.                         break;

  107. 

  108.                     case 3:

  109.                         testComponent.assetsPPU = 100;

  110.                         testComponent.refResolutionX = 400;

  111.                         testComponent.refResolutionY = 300;

  112.                         testComponent.upscaleRT = true;

  113.                         testComponent.pixelSnapping = true;

  114.                         testComponent.cropFrameX = true;

  115.                         testComponent.cropFrameY = false;

  116.                         testComponent.stretchFill = false;

  117.                         screenWidth = 1600;

  118.                         screenHeight = 1200;

  119. 

  120.                         expected.zoom = 4;

  121.                         expected.useOffscreenRT = true;

  122.                         expected.offscreenRTWidth = 400;

  123.                         expected.offscreenRTHeight = 300;

  124.                         expected.pixelRect = new Rect(0.0f, 0.0f, 400, 300);

  125.                         expected.orthoSize = 1.5f;

  126.                         expected.unitsPerPixel = 0.01f;

  127.                         break;

  128. 

  129.                     case 4:

  130.                         testComponent.assetsPPU = 100;

  131.                         testComponent.refResolutionX = 400;

  132.                         testComponent.refResolutionY = 300;

  133.                         testComponent.upscaleRT = true;

  134.                         testComponent.pixelSnapping = true;

  135.                         testComponent.cropFrameX = false;

  136.                         testComponent.cropFrameY = false;

  137.                         testComponent.stretchFill = false;

  138.                         screenWidth = 1600;

  139.                         screenHeight = 1100;

  140. 

  141.                         expected.zoom = 3;

  142.                         expected.useOffscreenRT = true;

  143.                         expected.offscreenRTWidth = 532;

  144.                         expected.offscreenRTHeight = 366;

  145.                         expected.pixelRect = new Rect(0.0f, 0.0f, 532, 366);

  146.                         expected.orthoSize = 1.83f;

  147.                         expected.unitsPerPixel = 0.01f;

  148.                         break;

  149. 

  150.                     case 5:

  151.                         testComponent.assetsPPU = 100;

  152.                         testComponent.refResolutionX = 400;

  153.                         testComponent.refResolutionY = 300;

  154.                         testComponent.upscaleRT = false;

  155.                         testComponent.pixelSnapping = false;

  156.                         testComponent.cropFrameX = false;

  157.                         testComponent.cropFrameY = false;

  158.                         testComponent.stretchFill = true;

  159.                         screenWidth = 800;

  160.                         screenHeight = 600;

  161. 

  162.                         expected.zoom = 2;

  163.                         expected.useOffscreenRT = false;

  164.                         expected.offscreenRTWidth = 0;

  165.                         expected.offscreenRTHeight = 0;

  166.                         expected.pixelRect = Rect.zero;

  167.                         expected.orthoSize = 1.5f;

  168.                         expected.unitsPerPixel = 0.005f;

  169.                         break;

  170. 

  171.                     case 6:

  172.                         testComponent.assetsPPU = 100;

  173.                         testComponent.refResolutionX = 400;

  174.                         testComponent.refResolutionY = 300;

  175.                         testComponent.upscaleRT = false;

  176.                         testComponent.pixelSnapping = false;

  177.                         testComponent.cropFrameX = true;

  178.                         testComponent.cropFrameY = true;

  179.                         testComponent.stretchFill = false;

  180.                         screenWidth = 800;

  181.                         screenHeight = 700;

  182. 

  183.                         expected.zoom = 2;

  184.                         expected.useOffscreenRT = true;

  185.                         expected.offscreenRTWidth = 800;

  186.                         expected.offscreenRTHeight = 600;

  187.                         expected.pixelRect = new Rect(0.0f, 0.0f, 800, 600);

  188.                         expected.orthoSize = 1.5f;

  189.                         expected.unitsPerPixel = 0.005f;

  190.                         break;

  191. 

  192.                     case 7:

  193.                         testComponent.assetsPPU = 100;

  194.                         testComponent.refResolutionX = 400;

  195.                         testComponent.refResolutionY = 300;

  196.                         testComponent.upscaleRT = false;

  197.                         testComponent.pixelSnapping = true;

  198.                         testComponent.cropFrameX = false;

  199.                         testComponent.cropFrameY = true;

  200.                         testComponent.stretchFill = false;

  201.                         screenWidth = 900;

  202.                         screenHeight = 600;

  203. 

  204.                         expected.zoom = 2;

  205.                         expected.useOffscreenRT = true;

  206.                         expected.offscreenRTWidth = 900;

  207.                         expected.offscreenRTHeight = 600;

  208.                         expected.pixelRect = new Rect(0.0f, 0.0f, 900, 600);

  209.                         expected.orthoSize = 1.5f;

  210.                         expected.unitsPerPixel = 0.01f;

  211.                         break;

  212. 

  213.                     case 8:

  214.                         testComponent.assetsPPU = 100;

  215.                         testComponent.refResolutionX = 400;

  216.                         testComponent.refResolutionY = 300;

  217.                         testComponent.upscaleRT = false;

  218.                         testComponent.pixelSnapping = true;

  219.                         testComponent.cropFrameX = true;

  220.                         testComponent.cropFrameY = false;

  221.                         testComponent.stretchFill = false;

  222.                         screenWidth = 900;

  223.                         screenHeight = 600;

  224. 

  225.                         expected.zoom = 2;

  226.                         expected.useOffscreenRT = true;

  227.                         expected.offscreenRTWidth = 800;

  228.                         expected.offscreenRTHeight = 600;

  229.                         expected.pixelRect = new Rect(0.0f, 0.0f, 800, 600);

  230.                         expected.orthoSize = 1.5f;

  231.                         expected.unitsPerPixel = 0.01f;

  232.                         break;

  233.                 }

  234. 

  235.                 testCaseArray[i] = new object[] { testComponent, screenWidth, screenHeight, expected };

  236.             }

  237. 

  238.             return testCaseArray;

  239.         }

  240. 

  241.         [Test, TestCaseSource("GetCalculateCameraPropertiesTestCases")]

  242.         public void CalculateCameraPropertiesProvidesCorrectResultsWithVariousInputs(PixelPerfectCameraTestComponent testComponent, int screenWidth, int screenHeight, CalculateCameraPropertiesResult expected)

  243.         {

  244.             PixelPerfectCameraInternal internals = new PixelPerfectCameraInternal(testComponent);

  245.             internals.CalculateCameraProperties(screenWidth, screenHeight);

  246. 

  247.             Assert.AreEqual(expected.zoom, internals.zoom);

  248.             Assert.AreEqual(expected.useOffscreenRT, internals.useOffscreenRT);

  249.             Assert.AreEqual(expected.offscreenRTWidth, internals.offscreenRTWidth);

  250.             Assert.AreEqual(expected.offscreenRTHeight, internals.offscreenRTHeight);

  251.             Assert.AreEqual(expected.pixelRect, internals.pixelRect);

  252.             Assert.AreEqual(expected.orthoSize, internals.orthoSize);

  253.             Assert.AreEqual(expected.unitsPerPixel, internals.unitsPerPixel);

  254.         }

  255. 

  256.         [Test]

  257.         public void CalculateFinalBlitPixelRectStretchToFitHeightWorks()

  258.         {

  259.             PixelPerfectCameraTestComponent testComponent = new PixelPerfectCameraTestComponent();

  260.             testComponent.refResolutionX = 200;

  261.             testComponent.refResolutionY = 100;

  262.             PixelPerfectCameraInternal internals = new PixelPerfectCameraInternal(testComponent);

  263. 

  264.             internals.useStretchFill = true;

  265.             Rect pixelRect = internals.CalculateFinalBlitPixelRect(400, 100);

  266. 

  267.             Rect expected = new Rect(100.0f, 0.0f, 200.0f, 100.0f);

  268.             Assert.AreEqual(expected, pixelRect);

  269.         }

  270. 

  271.         [Test]

  272.         public void CalculateFinalBlitPixelRectStretchToFitWidthWorks()

  273.         {

  274.             PixelPerfectCameraTestComponent testComponent = new PixelPerfectCameraTestComponent();

  275.             testComponent.refResolutionX = 200;

  276.             testComponent.refResolutionY = 100;

  277.             PixelPerfectCameraInternal internals = new PixelPerfectCameraInternal(testComponent);

  278. 

  279.             internals.useStretchFill = true;

  280.             Rect pixelRect = internals.CalculateFinalBlitPixelRect(200, 200);

  281. 

  282.             Rect expected = new Rect(0.0f, 50.0f, 200.0f, 100.0f);

  283.             Assert.AreEqual(expected, pixelRect);

  284.         }

  285. 

  286.         [Test]

  287.         public void CalculateFinalBlitPixelRectCenteredWorksWithUpscaleRT()

  288.         {

  289.             PixelPerfectCameraTestComponent testComponent = new PixelPerfectCameraTestComponent();

  290.             testComponent.upscaleRT = true;

  291.             testComponent.refResolutionX = 400;

  292.             testComponent.refResolutionY = 300;

  293.             PixelPerfectCameraInternal internals = new PixelPerfectCameraInternal(testComponent);

  294. 

  295.             internals.useStretchFill = false;

  296.             internals.zoom = 2;

  297.             internals.offscreenRTWidth = 400;

  298.             internals.offscreenRTHeight = 300;

  299. 

  300.             Rect pixelRect = internals.CalculateFinalBlitPixelRect(1600, 1200);

  301. 

  302.             Rect expected = new Rect(400.0f, 300.0f, 800.0f, 600.0f);

  303.             Assert.AreEqual(expected, pixelRect);

  304.         }

  305. 

  306.         [Test]

  307.         public void CalculateFinalBlitPixelRectCenteredWorksWithoutUpscaleRT()

  308.         {

  309.             PixelPerfectCameraTestComponent testComponent = new PixelPerfectCameraTestComponent();

  310.             testComponent.upscaleRT = false;

  311.             testComponent.refResolutionX = 400;

  312.             testComponent.refResolutionY = 300;

  313.             PixelPerfectCameraInternal internals = new PixelPerfectCameraInternal(testComponent);

  314. 

  315.             internals.useStretchFill = false;

  316.             internals.zoom = 2;

  317.             internals.offscreenRTWidth = 400;

  318.             internals.offscreenRTHeight = 300;

  319. 

  320.             Rect pixelRect = internals.CalculateFinalBlitPixelRect(1600, 1200);

  321. 

  322.             Rect expected = new Rect(600.0f, 450.0f, 400.0f, 300.0f);

  323.             Assert.AreEqual(expected, pixelRect);

  324.         }

  325.     }

  326. }