Unity3d ngui adaptive screen resolution)

Address: http://blog.csdn.net/asd237241291/article/details/8126619

If you need to reprint the original article, please note: Reprinted from the off-mosoft unity3d learning tour this article link address: unity3d ngui adaptive screen resolution 1. uiroot: According to the height of adaptive screen resolution. The ngui root directory's uiroot component comes with a highly adaptive resolution feature. You can select three scaling policies for the scaling style attribute.

1. Pixelperfect perfect pixels: displays the set pixels directly. Scaled down when the screen height is lower than minimum height, and scaled up when the screen height is greater than maximum height.
2. Fixedsize scale proportionally: Scale proportionally based on the preset settings.
3. Fixedsizeonmobiles in combination, Android and IoS are fixedsize, and others are in pixelperfect mode.

// Fixedsize: Specify the ideal resolution height.
// Fixedsizeofwidth: Specify the width of the ideal resolution.

Manual height:Follow the ideal resolution. When the game view (the screen resolution After packaging) is not the ideal resolution, proportional scaling is performed.

 

Minimum Height: The game view scales proportionally below this value.
Maximum height: The game view scales proportionally above this value.

All the three scaling methods calculate the zooming ratio based on the height and ignore the width completely.

At the time of creation, the UI ratio is based on the longest 16: 9 (red), and the other 3: 2 (green) is the content area. The two sides of the red color have different degrees of cutting on different proportions of mobile phones, so do not place the game content in this area. 2. uiroot: adaptive screen resolution based on the width. Uiroot has implemented the highly adaptive function, but my current requirement is to adapt according to the width, and leave blank when the screen height is higher than the UI height. 1. First, add a state to uiroot.

1. Public Enum Scaling
2. {
3. Pixelperfect,
4. Fixedsize,
5. Fixedsizeonmobiles,
6. /// <Summary>
7. /// Fit according to the width
8. /// </Summary>
9. Fixedsizeofwidth,
10. }

2. The implementation still requires the fixedsize algorithm, so you need to modify two judgment statements. 1:

1. Public float getpixelsizeadjustment (INT height)
2. {
3. Height = mathf. Max (2, height );
4. // Modify 1
5. If (scalingstyle = scaling. fixedsize | scalingstyle = scaling. fixedsizeofwidth)
6. Return (float) manualheight/height;
7.  
8. # If unity_iphone | unity_android
9. If (scalingstyle = scaling. fixedsizeonmobiles)
10. Return (float) manualheight/height;
11. # Endif
12. If (height <minimumheight) Return (float) minimumheight/height;
13. If (height> maximumheight) Return (float) maximumheight/height;
14. Return 1f;
15. }

Modify 2:

1. Public int activeheight
2. :{
3. Get
4. {
5. Int Height = mathf. Max (2, screen. Height );
6. // Modify 2
7. If (scalingstyle = scaling. fixedsize | scalingstyle = scaling. fixedsizeofwidth)
8. Return manualheight;
9. # If unity_iphone | unity_android
10. If (scalingstyle = scaling. fixedsizeonmobiles)
11. Return manualheight;
12. # Endif
13. If (height <minimumheight) return minimumheight;
14. If (height> maximumheight) return maximumheight;
15. Return height;
16. }
17. }

3. added a width-based adaptive algorithm.

1. Void Update ()
2. {
3. # If unity_editor
4. If (! Application. isplaying & gameobject. layer! = 0)
5. Unityeditor. editorprefs. setint ("ngui layer", gameobject. Layer );
6. # Endif
7. If (mtrans! = NULL)
8. {
9. Float calcactiveheight = activeheight;
11. If (calcactiveheight> 0f)
12. {
13. Float size = 2f/calcactiveheight;
15. // Here, here, here
16. If (scalingstyle = scaling. fixedsizeofwidth)
17. {
18. Float radio = (float) screen. width/screen. height;
19. Size = size * radio;
20. }
22. Vector3 ls = mtrans. localscale;
24. If (! (Mathf. Abs (LS. X-size) <= float. epsilon) |
25. ! (Mathf. Abs (LS. Y-size) <= float. epsilon) |
26. ! (Mathf. Abs (LS. Z-size) <= float. epsilon ))
27. {
28. Mtrans. localscale = new vector3 (size, size, size );
29. }
30. }
31. }
32. }

3. uistretch: adaptive screen resolution based on the width. (Not supported by ngui3.0.7) This is a method for implementing adaptive differentiation rates for ngui in earlier versions. After the uiroot adaptive method is added to the new version, this script will not be officially recommended. In addition to the highly adaptive function, the style provided by this script also requires image stretching Based on the width and cannot meet our requirements. Basedonheight is the most suitable for us, so we can modify the basedonwidth according to this function. This function has been written in the previous blog. Now this article replaces the previous one, so I will post the modified content. First, add a basedonwidth in the style enumeration, Type

1. Public Enum Style
2. {
3. None,
4. Horizontal,
5. Vertical,
6. Both,
7. Basedonheight,
8. Basedonwidth,
9. Fillkeepingratio,
10. Fitinternalkeepingratio
11. }

Add an if branch to the update method.

1. If (style = style. basedonheight)
2. {
3. Localscale. x = relativesize. x * rectheight;
4. Localscale. Y = relativesize. y * rectheight;
5. } Else if (style = style. basedonwidth)
6. {
7. Localscale. x = relativesize. x * rectwidth;
8. Localscale. Y = relativesize. y * rectwidth;
9. }
10. Else if (style = style. fillkeepingratio)
11. {......}

This script is implemented by stretching scale, so this script should be placed on the UI you need to stretch (if you only need a background image to adapt to the screen resolution, add the script to the background image. If you want all the elements in a panel to be adaptive, place the script on the panel. If you want to make all the UIS adaptive resolution, put it on ngui's cameta .) For the UI camera attribute, You must select the camera that renders the current UI. Step 1: Set the game view to an ideal width (then scale according to this ratio .). 2. Select an object for uistretch as needed and add this component. Assign a value to the UI cameta. 3. Change the size of the UI cameta to the width of the current screen. (The scale X and Y of this object have been set to the screen width by uistrech, and this value cannot be modified .) 4. Change the window width at this time. Only the scale X and Y of the object have been automatically modified, and the UI view has been automatically adapted ~!