Unity 2Dでアスペクト比の違いをどのように処理しますか?


67

私はこの質問に対して多くの回答を得ましたが、それらはすべて一般的であり、一般的にはあまり有用ではありません。いずれのチュートリアルもアスペクト比とモバイルデバイスの取り扱いについては説明しておらず、それを行う方法は無数にありますが、すべてが落とし穴と欠陥を持っているようです。

無数の異なるサイズのアセットを作成することなく、iOSとAndroidで異なるアスペクト比を処理するために成功したゲームがどのように使用されているかを知りたいです。

特にUnityでは、デスクトップではなくモバイルを厳密に話しています。UIについては気にしません。ゲームプレイキャンバスについてのみ気にします。

私が念頭に置いている問題は、特定の場所にある必要があり、画面から落ちることができない重要なものがある場合です。最近、上部または下部に黒いバーを使用することは受け入れられません。


3
正しい方法はほとんど何にも依存するため、この質問は非常に広範です。何を試しましたか?なぜ機能しなかったのですか?
アンコ14年

3
いろいろなことを試し、オルソカメラのサイズを調整し、リストにすべてのスプライトをアタッチし、アスペクト比の違いでそれらをスケーリングし、オルソサイズをscreen.height / 2/100に設定してみました。アイデア。一部は機能しますが、すべてに問題があります。ゲームごとに処理方法が異なることは知っていますが、このトピックについての議論はどこにもありません。また、「団結させて処理する」ほど簡単ではありません。
マイケル14年

1
では、なぜ機能しなかったのですか?良い解決策はどのようなものでしょうか?(ところで、質問を編集して明確にすることもできます。)
アンコ14年

7
画像を歪める人もいれば、正しく整列しない人もいました。多くのさまざまな問題がありますが、Unityで開発されたゲームの65%は2Dであり、機能しました。人々が使用しているものを知りたいだけで、車輪を再発明する必要はありません。誰もそれについて話しませんし、それを処理する方法に関するガイドやドキュメントもありません。しかし、それを行うためのシステムがなければ、モバイルプロジェクトで大きな成果を上げることはできません。
マイケル14年

1
「私が頭に抱えている問題は、特定の場所にある必要があり、画面から落ちない重要なものがある場合です。最近、上下に黒いバーを使用することは受け入れられません。」画面から落ちない要素、歪みゼロ、保証書/ピラーボクシング(黒いバーなど)はありません。これらの要件は両立しません。最後の要件はおそらく最も重要ではないか、画面上にある必要があるものを超えてキャンバスをパディングすることで非表示にすることができます。私がこのような厳しい要件で見たほとんどのゲームには、ピラーボックス/境界線が装飾されています。
ジブスマート

回答:


36

必要なのは、camera.orthographicSizeプロパティを計算することにより、(必要に応じて)ポートレートまたはランドスケープのカメラビューポートを制限することです。これにより、アスペクト比と解像度に関係なく2Dシーンを構築できます。

// Attach this script on your main ortohgraphic camera:

/* The MIT License (MIT)

Copyright (c) 2014, Marcel Căşvan

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE. */

using System;
using System.Collections;
using UnityEngine;

[ExecuteInEditMode]
[RequireComponent (typeof (Camera))]
public class ViewportHandler : MonoBehaviour
{
    #region FIELDS
    public Color wireColor = Color.white;
    public float UnitsSize = 1; // size of your scene in unity units
    public Constraint constraint = Constraint.Portrait;
    public static ViewportHandler Instance;
    public new Camera camera;

    private float _width;
    private float _height;
    //*** bottom screen
    private Vector3 _bl;
    private Vector3 _bc;
    private Vector3 _br;
    //*** middle screen
    private Vector3 _ml;
    private Vector3 _mc;
    private Vector3 _mr;
    //*** top screen
    private Vector3 _tl;
    private Vector3 _tc;
    private Vector3 _tr;
    #endregion

    #region PROPERTIES
    public float Width {
        get {
            return _width;
        }
    }
    public float Height {
        get {
            return _height;
        }
    }

    // helper points:
    public Vector3 BottomLeft {
        get {
            return _bl;
        }
    }
    public Vector3 BottomCenter {
        get {
            return _bc;
        }
    }
    public Vector3 BottomRight {
        get {
            return _br;
        }
    }
    public Vector3 MiddleLeft {
        get {
            return _ml;
        }
    }
    public Vector3 MiddleCenter {
        get {
            return _mc;
        }
    }
    public Vector3 MiddleRight {
        get {
            return _mr;
        }
    }
    public Vector3 TopLeft {
        get {
            return _tl;
        }
    }
    public Vector3 TopCenter {
        get {
            return _tc;
        }
    }
    public Vector3 TopRight {
        get {
            return _tr;
        }
    }
    #endregion

    #region METHODS
    private void Awake()
    {
        camera = GetComponent<Camera>();
        Instance = this;
        ComputeResolution();
    }

    private void ComputeResolution()
    {
        float leftX, rightX, topY, bottomY;

        if(constraint == Constraint.Landscape){
            camera.orthographicSize = 1f / camera.aspect * UnitsSize / 2f;    
        }else{
            camera.orthographicSize = UnitsSize / 2f;
        }

        _height = 2f * camera.orthographicSize;
        _width = _height * camera.aspect;

        float cameraX, cameraY;
        cameraX = camera.transform.position.x;
        cameraY = camera.transform.position.y;

        leftX = cameraX - _width / 2;
        rightX = cameraX + _width / 2;
        topY = cameraY + _height / 2;
        bottomY = cameraY - _height / 2;

        //*** bottom
        _bl = new Vector3(leftX, bottomY, 0);
        _bc = new Vector3(cameraX, bottomY, 0);
        _br = new Vector3(rightX, bottomY, 0);
        //*** middle
        _ml = new Vector3(leftX, cameraY, 0);
        _mc = new Vector3(cameraX, cameraY, 0);
        _mr = new Vector3(rightX, cameraY, 0);
        //*** top
        _tl = new Vector3(leftX, topY, 0);
        _tc = new Vector3(cameraX, topY , 0);
        _tr = new Vector3(rightX, topY, 0);           
    }

    private void Update()
    {
        #if UNITY_EDITOR
        ComputeResolution();
        #endif
    }

    void OnDrawGizmos() {
        Gizmos.color = wireColor;

        Matrix4x4 temp = Gizmos.matrix;
        Gizmos.matrix = Matrix4x4.TRS(transform.position, transform.rotation, Vector3.one);
        if (camera.orthographic) {
            float spread = camera.farClipPlane - camera.nearClipPlane;
            float center = (camera.farClipPlane + camera.nearClipPlane)*0.5f;
            Gizmos.DrawWireCube(new Vector3(0,0,center), new Vector3(camera.orthographicSize*2*camera.aspect, camera.orthographicSize*2, spread));
        } else {
            Gizmos.DrawFrustum(Vector3.zero, camera.fieldOfView, camera.farClipPlane, camera.nearClipPlane, camera.aspect);
        }
        Gizmos.matrix = temp;
    }
    #endregion

    public enum Constraint { Landscape, Portrait }
}

これについてさらに情報が必要な場合は、お問い合わせください。返信させていただきます。;)よろしくお願いします。

更新:Eliot Lashのオブジェクトアンカースクリプトをこれと一緒に使用して、必要に応じて(画面のコーナー/境界に対して)画面上のキー位置にオブジェクトを配置します。その場合、「CameraFit」の名前を「ViewportHandler」に変更します。

さまざまなアスペクト比画面をシミュレートするプレビュー: ここに画像の説明を入力してください


4
@Eliotは上記のMITライセンスを追加しました。あなたのプロジェクトで頑張ってください!
androidu

7
素晴らしい、ありがとう!:一つの良いターンは、私はちょうどあなたのスクリプトで定義されたヘルパーポイントにゲームオブジェクトの簡単な係留のために書いたオープンソースコンポーネントですので、ここでは、別のに値するgist.github.com/fadookie/256947788c364400abe1
エリオット・

1
MarcelCăşvan非常に素晴らしいスクリプト!ランドスケープのpotraitの単位サイズ(高さ/幅)を定義するかどうかを選択する列挙型を追加しました。ただ、スクリプトに数行を追加する必要がありました、そして、私が使用してGetComponent<Camera>().orthographicSize = UnitSize / 2f;、高さの単位を定義/ potraitのために
am_

2
@MarcelCăşvan素晴らしいもの!ありがとう。ComputeFunction()のdeviceWidth変数とdeviceHeight変数が使用されていないことがわかります。おそらくこれらを削除することを検討してください。
user2313267

1
CameraAnchorがエラーを投げています:「CameraFitはこのコンテキストでは定義されていません」-他の誰かがこの回答を後で見つけた場合、「CameraFit」は最初に投稿されてから「ViewportHandler」に名前を変更したようです。クラスの名前をViewportHandlerからCameraFitに戻すだけの場合。
レニー

5

通常、異なるサイズのアセットは必要ありません-画像の元のピクセルサイズ以下のサイズでレンダリングした場合、インポートされたテクスチャと自動生成されたミップマップを備えたスプライトは見栄えがします。

シーンのレイアウトが課題です。良いアプローチの1つは次のとおりです(参考までに、z = 0に配置された2Dコンテンツを見る3Dカメラを使用しています)

  1. ピクセルまたはタイルの最小「論理」表示サイズを任意に決定します。これは、実際の解像度に対応する必要はありませんが、サポートする最小/最小アスペクト比を反映する必要があります。たとえば、ランドスケープゲームの場合、480x320はiPadよりも広いアスペクト比なので選択しません。したがって、1024x768または480x360を選択することもできます。これにより、動作するiPhoneサイズの元の座標系と、すべてのiPad(iPad Air 2などを含む)と同じアスペクト比が得られます。また、ピクセル座標ではなくタイル座標(15x11.25など)で簡単に作業できることに注意してください。
  2. ゲームロジックをプログラムして、重要なすべてのものを最小ディスプレイサイズ内に配置する(または配置できる)が、装飾的なフィラーであっても、追加のコンテンツで側面の余分なスペースを満たすように準備します。
  3. 幅または高さのいずれかが最小値に一致し、他の軸が必要な最小値以上になるように、コンテンツをどれだけスケーリングする必要があるかを決定します。この「フィットする縮尺」を行うには、画面のピクセルサイズを最小表示サイズで除算し、結果の縮尺値の小さい方を全体の表示縮尺にします。
  4. ビュースケールを使用して、ゲームロジックの目的で有効な(実際の)ディスプレイサイズを計算します。
  5. Z軸に沿ってカメラを移動して、実際にコンテンツをスケーリングします。

コード形式:

  // Adjust the camera to show world position 'centeredAt' - (0,0,0) or other - with
  // the display being at least 480 units wide and 360 units high.

  Vector3 minimumDisplaySize = new Vector3( 480, 360, 0 );

  float pixelsWide = camera.pixelWidth;
  float pixelsHigh = camera.pixelHeight;

  // Calculate the per-axis scaling factor necessary to fill the view with
  // the desired minimum size (in arbitrary units).
  float scaleX = pixelsWide / minimumDisplaySize.x;
  float scaleY = pixelsHigh / minimumDisplaySize.y;

  // Select the smaller of the two scale factors to use.
  // The corresponding axis will have the exact size specified and the other 
  // will be *at least* the required size and probably larger.
  float scale = (scaleX < scaleY) ? scaleX : scaleY;

  Vector3 displaySize = new Vector3( pixelsWide/scale, pixelsHigh/scale, 0 );

  // Use some magic code to get the required distance 'z' from the camera to the content to display
  // at the correct size.
  float z = displaySize.y /
            (2 * Mathf.Tan((float)camera.fieldOfView / 2 * Mathf.Deg2Rad));

  // Set the camera back 'z' from the content.  This assumes that the camera
  // is already oriented towards the content.
  camera.transform.position = centeredAt + new Vector3(0,0,-z);

  // The display is showing the region between coordinates 
  // "centeredAt - displaySize/2" and "centeredAt + displaySize/2".

  // After running this code with minimumDisplaySize 480x360, displaySize will
  // have the following values on different devices (and content will be full-screen
  // on all of them):
  //    iPad Air 2 - 480x360
  //    iPhone 1 - 540x360
  //    iPhone 5 - 639x360
  //    Nexus 6 - 640x360

  // As another example, after running this code with minimumDisplaySize 15x11
  // (tile dimensions for a tile-based game), displaySize will end up with the following 
  // actual tile dimensions on different devices (every device will have a display
  // 11 tiles high and 15+ tiles wide):
  //    iPad Air 2 - 14.667x11
  //    iPhone 1 - 16.5x11
  //    iPhone 5 - 19.525x11
  //    Nexus 6 - 19.556x11

2

あなたがバーを使用することになったら、実際に実装するのはかなり簡単です(モバイルではそれほど悪くないという利点があり、それは簡単な解決策であるため、OPは容認できないという意見を述べていますが、これを投稿していますコードは一切必要ありません)

Camera.orthographicSizeは、オルソカメラ(ほとんどの2Dゲームが使用する)内の変数であり、測定されたゲームユニットの量を画面上で垂直に(2で割った値)に合わせます(ソース)。したがって、大部分のデバイスに適合するアスペクト比を選択し(調査したほとんどの画面は16:9、16:10、3:2であるため16:9を選択しました)、その比率でオーバーレイするマスクを追加します。

私のゲームでは(これは広告ではないため、ここにリストされていません。必要に応じてコメントで尋ねることができます)、ポートレートモードを使用します。素晴らしくシンプルな16:9を行うために、Orthoカメラをサイズ16で作成しました。これは、カメラが32ゲーム単位の高さ(私の場合は16〜-16)を画面のデバイスの垂直方向に適応させることを意味します。

次に、-9〜+9のゲームで黒いマスクを配置しました。Voila、ゲームの画面はすべてのデバイスでまったく同じに見え、少し幅の広いデバイスでは少し細く見えます。私は、マスクに関する否定的なフィードバックはまったくありませんでした。ランドスケープを行うには、単にそれらの値を反転させてから、サイズ9のカメラを作成します。ゲームユニットのスケールを決定したものに合わせて値を変更します。

黒いバーが顕著に表示されるのを確認した唯一の場所は、iPadの3:2です。それでも、不満はありませんでした。


1

現在取り組んでいるゲームでこれをやっています。1140x720の背景画像があります。最も重要なビット(絶対にトリミングされないビット)は、960x640の中間領域に含まれています。カメラの開始関数でこのコードを実行します。

    float aspect = (float)Screen.width / (float)Screen.height;

    if (aspect < 1.5f)
        Camera.main.orthographicSize = 3.6f;
    else
        Camera.main.orthographicSize = 3.2f;

    float vertRatio = Screen.height / 320.0f;
    fontSize = (int)(12 * vertRatio);

ボタンなどのフォントサイズ以外のサイズも定義します。テストしたすべてのアスペクト比でうまく機能します。設定してからしばらく経ちましたので、足りないかもしれません。期待どおりに動作しない場合はお知らせください。何かを省略したかどうかを確認します。


1

@Marcelの答えとコードは素晴らしく、何が起きているのかを理解するのに役立ちました。それが決定的な答えです。誰かが私の特定のケースのために私がやったことを役立たせるかもしれないと思っただけです:私は本当に本当にシンプルなものを望んでいたので、1つのスプライトを常に画面に表示したので、私はこれらのいくつかの行を思い付きました:

public class CameraFit : MonoBehaviour {

    public SpriteRenderer spriteToFitTo;

    void Start () { // change to Update to test by resizing the Unity editor window
        var bounds = spriteToFitTo.bounds.extents;
        var height = bounds.x / camera.aspect;
        if (height < bounds.y)
            height = bounds.y;
        camera.orthographicSize = height;
    }
}

これをカメラに追加し、スプライト(私の背景)をスクリプトの唯一のプロパティにドラッグしました。黒いバー(水平または垂直)が必要ない場合は、このバーの後ろに大きな背景を配置できます。


0

この問題に取り組むにはいくつかの方法があり、完璧な解決策はありません(少なくとも私はまだ見つけていません)。あなたが行く解決策の種類はあなたがしているゲームの種類に大きく依存するでしょう現像。

あなたが何をしていようと、サポートしたい最低の解像度を選択し、その解像度に合わせてスプライトを構築することから始めてください。したがって、http: //www.iosres.com/によると、iOS向けの開発に関心がある場合、iOSデバイスの最低解像度は480x320です。

そこから、高解像度に合わせてスプライトのスケールアップを開始できます。これに対する注意点は、最終的にスプライトがスケールをさらに大きくぼかすことに気づき始めることです。その場合、より高い解像度用に構築されたスプライトの別のセットに切り替えることができます。

または、スケーリングを完全に無視し、より高い解像度のためにゲーム画面をより多く表示することを決定できます(たとえば、Terrariaがこれを行う方法だと思います)。ただし、多くのゲームでは、これは適切ではありません。たとえば、競争力のあるゲーム。

最近、上部または下部に黒いバーを使用することは受け入れられません。

それは...ですか?4:3のアスペクト比を強制する多くのゲームがこれを行います。Unityを使用しているため、AspectRatioEnforcerスクリプトを使用してこれを支援できます。


モバイルをターゲットにしているため、アスペクト比や解像度を変更できません。低解像度のアセットを使用することは、許容できる解決策ではありません。一部のゲーム(特に3D)は問題ではなく、多かれ少なかれ表示されます。しかし、Kingdom Rush、タワーディフェンス、その他のAlexなどのゲームは、デバイスに関係なく同じものを見たいと思っています。適切な場所に物事が表示されない場合、ゲームは正常に動作しません。
マイケル14


0

この問題を処理するには複数の方法がありますが、それはあなたのゲームと何が最適かによって異なります。たとえば、ゲームTyrant Unleashedでは、幅の狭いマップで側面の重要度の低い詳細を単純に作成したため、幅の狭いデバイスで側面を切り取ってもかまいません。ただし、他のゲームでは、実際にボタンを移動したり、画面に合わせて何かを移動したりするアプローチの方が適している場合があります。

(私たちのアプローチの一部は、幅を変えるだけですべてのデバイスで一貫した高さを維持することでもあります。これは確かに私たちの生活を楽にしますが、これはあなたの特定のゲームに良いかもしれませんし、そうでないかもしれません。画像が異なる画面で少し拡大縮小される場合のアートスタイルですが、これはピクセルアートのようなものにとって重要かもしれません。これは基本的に「Unityに処理させる」アプローチです。


それが選択肢ではなかったプロジェクトをやったことがありますか?私が見たほとんどすべてのタワーディフェンススタイルのゲームと他の多くのスタイルは、スクロールせずにデバイス上でゲーム全体を見ることができ、これはデバイス間で一貫しています。IOSでは、アセットを作成してスワップできますが、Androidではそれが不可能になります(とにかく大きなPITAになります)。
マイケル14

いいえ、私はしていません。ところで私は、画面サイズについていくつかの詳細を追加
jhocking

0

targetAspectカメラにパラメーターを追加orthographicSizeし、画面の比率に応じてパラメーターを調整する次のスクリプトを使用しています(詳細については、このブログ記事を参照しください)。

using UnityEngine;
using System.Collections;

public class AspectRatioScript : MonoBehaviour {

    public float targetAspect;

    void Start () 
    {
        float windowAspect = (float)Screen.width / (float)Screen.height;
        float scaleHeight = windowAspect / targetAspect;
        Camera camera = GetComponent<Camera>();

        if (scaleHeight < 1.0f)
        {  
            camera.orthographicSize = camera.orthographicSize / scaleHeight;
        }
    }
}

0

私の方法は、他の人によって与えられた解決策にほとんど似ています:)私は、画面サイズに依存しないゲームを作るためにとるアプローチを詳細に説明しようとします。

画面の向き

画面の向き(LandscapeまたはPortrait)に応じて、カメラが固定の高さまたは固定の幅で拡大縮小するかどうかを考慮する必要があります。ほとんどの場合、横向きのゲームでは固定幅を選択し、縦向きのゲームでは固定幅を選択します。

カメラのスケーリング

説明したように、これは固定高さまたは固定幅のいずれかです。

固定高さ:ゲームの垂直領域は常に画面の高さに適合します。また、画面の縦横比が変わると、画面の左右に余分なスペースが追加されます。これを実装するために、何もコーディングする必要はありません。それは単一カメラのデフォルトの動作です。

固定幅:ゲームの水平領域は常に画面幅に適合します。また、画面の縦横比が変わると、上部と下部に余分なスペースが追加されます。これを実装するには、小さなコードを書く必要があります。後で、コードフォーム更新関数を削除して、スリープ状態にしないでください。

using UnityEngine;

[ExecuteInEditMode]
public class ScaleWidthCamera : MonoBehaviour {

    public int targetWidth = 640;
    public float pixelsToUnits = 100;

    void Update() {

        int height = Mathf.RoundToInt(targetWidth / (float)Screen.width * Screen.height);

        camera.orthographicSize = height / pixelsToUnits / 2;
    }
}

エディターでtargetWidthを変更して、表示するワールドスペースエリアを定義できます。このコードは、2Dゲームの他の多くのプラクティスとともに、次のビデオで説明されています:)

Unite 2014-Unityの2Dベストプラクティス

アスペクト比

最も広いものから最も狭いものまでリストされたアスペクト比に従って、AndroidとiOSの両方のほぼすべての画面サイズをカバーします

  • 5:4
  • 4:3
  • 3:2
  • 16:10
  • 16:9

通常、これらのアスペクト比はすべて、ゲームウィンドウの下で指定された順序で設定します。さまざまな画面サイズをテストする際に便利です。

消耗品エリア

これは、選択したカメラのスケーリングに応じて、画面の側面または上部/下部に追加される領域です。

固定された高さの場合、すべてのゲーム要素は、最も狭い16:9の比率に収まることが望ましいです。そして、背景は5:4の比率をカバーするまで拡大する必要があります。これにより、ゲームの両側に黒い帯ができなくなります。

固定幅の場合、ほぼ同じですが、ここでは要素は5:4の比率に収まり、BGは16:9まで伸びます。

境界

ゲームプレイに利用可能な画面全体を利用する必要があるため、消費可能な領域のアプローチを使用できない場合があります。

たとえば、空から落ちてくるコインをキャッチする、高さを固定したポートレートゲームを考えてみましょう。これでは、プレーヤーが使用可能な画面幅を水平に移動できるようにする必要があります。

したがって、カメラの左、右、上、または下が正確にワールド位置でクリップする場所を知るには、ワールド座標の観点からカメラの境界が必要です。
これらの境界を使用して、ゲーム要素またはUIをカメラの目的の側に固定することもできます。

Camera.ViewportToWorldPointを使用して、bounds.Viewportスペースを取得できます。これは、カメラに対して相対的に正規化されています。カメラの左下は(0,0)です。右上は(1,1)です。z位置は、カメラからのワールド単位です。2D /正投影では、zは重要ではありません。

Vector3 leftBottom = camera.ViewportToWorldPoint(new Vector3(0, 0, camera.nearClipPlane));
Vector3 rightTop = camera.ViewportToWorldPoint(new Vector3(1, 1, camera.nearClipPlane));

float left = leftBottom.x;
float bottom = leftBottom.y;
float right = rightTop.x;
float top = rightTop.y;

UI

UIには、ゲーム要素に使用したものと同じ概念を適用できます。Unity5 UIの導入とNGUIのようなプラグインの可用性の後、これは大した問題にはなりません:)


0

Unityアセット「Resolution Magic 2D」を作成して、まさにこの問題を解決しました(広告:Unityアセットストアから入手するか、grogansoft.comで詳細を確認できます)。

私が問題に取り組んだ方法は次のとおりでした...

アスペクト比/解像度に関係なく常に表示されなければならない画面の領域を定義し、この領域を「ステンシルアウト」するために単純な長方形変換を使用します。これが理想的な画面形状です。単純なアルゴリズムを使用して、長方形でブロックされた領域ができるだけ大きくなるまでカメラをズームしますが、カメラからは100%見えます。

それから、あなたのメインゲームエリアは常に可能な限り多くのスクリーンを占有しています。そして、前に定義した長方形領域の外側に十分な「余分な」コンテンツ(背景など)がある限り、画面が「理想的な」長方形と同じアスペクト比ではないプレイヤーは、そうでなければ黒いバーが表示される追加コンテンツを見ることができます行く。

私の資産にはUIを配置するためのロジックも含まれていますが、Unityの新しいUIシステムのため、ほとんどが廃止されています。

私の資産は、最小限のセットアップですぐにこれを提供し、すべてのプラットフォームで非常にうまく機能します。

この手法(または私の資産)を使用する場合は、理想よりも広いまたは高い画面に対応するために(黒いバーを避けるために)ゲームを設計してください。

私は個人的に3Dゲームを作成していません。そのため、これが3Dで機能するかどうか(または必要な場合でも)わかりません。

写真なしで説明するのは本当に難しいので、私のウェブサイトにアクセスしてください(Resolution Magic 2D


0

私にとって最良の解決策は、交差する線の定理を使用して、側面のカットオフやゲームビューの歪みが生じないようにすることです。つまり、異なるアスペクト比に応じて、前後に移動する必要があります。


-3

私はと呼ばれる簡単に縦横切り替えを可能AssetStore拡張子作成AspectSwitcherを。さまざまな側面のさまざまなプロパティを簡単に指定できるシステムを提供します。通常、ほとんどの人がアスペクトを切り替えるために使用する2つの方法があります。1つは、アスペクトごとに異なるゲームオブジェクトを提供することです。もう1つは、現在のアスペクトに基づいて単一のゲームオブジェクトのプロパティを変更するカスタムコードを作成することです。通常、これには多くのカスタムコーディングが必要です。私の拡張機能は、その痛みの多くを軽減しようとします。


2
OPの質問に対処するために使用できる実際の手法について詳しく説明した場合、この回答の方が優れており、スパムが少ないように見えます。
ジョシュ
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.