c# - Unity-如何旋转和全屏视频，在RawImage上使用VideoPlayer API播放

由于在Unity 5.6.0b1之后不推荐使用MovieTexture，因此我通过使用here的引用，使用 VideoPlayer Api在Android上通过RawImage播放视频。
我正在尝试添加一个切换开关，以从在RawImage Texture上播放的视频的初始大小切换到全屏，并在视频停止后恢复到原始大小。

我有一个完美播放的视频，到目前为止，我可以使用此代码将视频的转换更改为全屏显示。

void Update () {
    if (Input.GetButtonDown("Jump"))
    {
        image.rectTransform.offsetMax = Vector2.Lerp(Vector2.up, Vector2.down, 100);
        image.rectTransform.offsetMin = Vector2.Lerp(Vector2.left, Vector2.right, 100);
        image.rectTransform.rotation = Quaternion.AngleAxis(Mathf.Lerp(0f, 90f, 50), Vector3.forward);
    }
}

if块内的前两行能够全屏显示RawImage，在该RawImage上播放视频会在图像的第2部分中显示效果。这是Vector2的文档。

对于旋转的第三行代码，我从this discussion on Unity Forum取得了引用，但是仍然没有得到我想要的效果，结果出现在第3节中。我想旋转RawImage的内容，但是我旋转RawImage本身，它可能是因为引用文献没有描述旋转内容。

谁能帮我找出解决方法。如果它对我使用的Unity版本有所帮助，请使用Unity 5.6.0b11 Beta，如果要在设备上进行测试，请下载示例项目。
Unity Video Player.zip 18.33MB您也可以遵循此Video Tutorial on new VideoPlayer from YouTube。



更新1

到目前为止，我唯一得到的是，我只尝试了旋转代码，并通过删除了if块中的前两行，就可以旋转视频，但是当我尝试拉伸(stretch)RawImage时，它就在拉伸(stretch)拉伸(stretch)。屏幕。 See here for the image

更新2

经过大量研究，命中和尝试。最后，我用该代码对RawImage进行了全屏和旋转，以在Unity上播放全屏视频。

image.rectTransform.offsetMin = new Vector2(-560, 560);
image.rectTransform.offsetMax = new Vector2(560, -560);

但是，正如您所看到的，我提供给向量的值是静态数字，不能保证可以在多种屏幕尺寸上使用。好吧，随着轴与RawImage一起旋转，旋转RawImage会造成困惑，但是某些组件没有更改或旋转，并且当更改偏移值时，RawImage会引用较早的Rect更改它的值(我真的不知道在这里发生)。


旋转RawImage旋转连接到它的轴。在上面的图像中，您可以看到RawImage旋转了，然后旋转了Axis。但是，即使旋转图像，您仍然可以看到一些引用线。



我如何尝试解决此问题？ [失败]

我试图以新的方式解决该问题，我创建了一个适合 Canvas 的新RawImage，并且已经旋转并作为先前的RawImage附加到脚本StreamVideo.cs。最初，它处于非 Activity 模式，并在用户命令全屏显示时切换为 Activity 模式。当全屏播放时，视频将在新的RawImage中播放。

public void playFullScreen() {
    isFullScreen = true;
    imageFullScreen.gameObject.SetActive(true);
    imageFullScreen.texture = videoPlayer.texture;
    image.gameObject.SetActive(false);
}

但是，我遇到了这样的问题，即当视频切换到全屏时，它会从新RawImage的同一帧开始播放视频，而切换回小屏时，会出现相同的问题。

摘要:

查看 update 2 ，我可以播放，暂停，全屏和旋转视频，但是使用offsetMax和offsetMin上的纯数字值。 我正在尝试了解是否有一种方法可以通过脚本来整理这些值以适合多种屏幕尺寸。我知道这听起来很简单，但棘手的部分是，对于我需要的屏幕，我提供的值的引用是这样的。注 Intent 片中的虚线矩形。

最佳答案

我想做同样的事情，但是碰到了同样的问题。我确实认为这是一个错误，但确实设法提出了解决方案。

这可以通过 anchor ，枢轴点和屏幕尺寸(Screen.width，Screen.height)或“ Canvas ”尺寸来完成。就我而言，我将使用“ Canvas ”的大小。

当您按住Alt键并单击RawImage的拉伸(stretch)图标RectTransform时，RawImage将全屏显示。您可以通过代码使用在编辑器中更改的值来执行相同的操作，如下所示:

rectTrfm.anchoredPosition3D = new Vector3(0, 0, 0);
//Stretch the Image so that the whole screen is totally covered
rectTrfm.anchorMin = new Vector2(0, 0);
rectTrfm.anchorMax = new Vector2(1, 1);
rectTrfm.pivot = new Vector2(0.5f, 0.5f);
rectTrfm.offsetMin = Vector2.zero;
rectTrfm.offsetMax = Vector2.zero;

它可以工作，并且应该为您提供全屏RawImage。问题在于，当旋转位于0和180时，或者仅当旋转上下颠倒时，它才起作用。当旋转为-90，90和270时，不起作用。如果RawImage向右或向左旋转，通常会得到这些角度。我怀疑这是一个错误。

要解决此问题，您可以从Canvas RectTransform的大小计算出宽高比，然后使用它来创建anchorMin和anchorMax。其余代码应保持不变。

RectTransform canvasRectTrfm = rawImage.canvas.GetComponent<RectTransform>();
float aspRatio = canvasRectTrfm.rect.size.x / canvasRectTrfm.rect.size.y;
float halfAspRatio = aspRatio / 2.0f;
float halfAspRatioInvert = (1.0f / aspRatio) / 2.0f;

rectTrfm.anchorMin = new Vector2(0.5f - halfAspRatioInvert, 0.5f - halfAspRatio);
rectTrfm.anchorMax = new Vector2(0.5f + halfAspRatioInvert, 0.5f + halfAspRatio);
rectTrfm.anchoredPosition3D = Vector3.zero;
rectTrfm.pivot = new Vector2(0.5f, 0.5f);
rectTrfm.offsetMin = Vector2.zero;
rectTrfm.offsetMax = Vector2.zero;

这应该适用于-90，90和270角度，但不适用于0和180的。这不是问题，因为我们的第一个代码适用于0和180角度。我们可以在运行时检测角度，并根据RawImage的当前角度执行代码。

您可以在下面的代码中看到将这两个代码组合为StretchImageFullScreen的完整功能。下面是一个示例代码，在完成Space键后，可以在全屏和RawImage的原始大小之间切换视频。要退出切换模式，请按R键。 RawImageInfo结构用于在切换到全屏之前复制RectTransform信息，以便在再次使用Space键切换或按R键时可以恢复默认位置/旋转。

将以下代码添加到other答案的代码中，您应该能够在全屏视频和默认RawImage大小之间切换，并且应该能够使用StretchImageFullScreen函数中的第二个参数对其进行旋转。

//Used to store RectTransform information so that original RawImage settings can be restored
public struct RawImageInfo
{
    public Vector3 anchorPos;
    public Vector2 widthAndHeight;
    public Vector2 anchorMin;
    public Vector2 anchorMax;
    public Vector2 pivot;

    public Vector2 offsetMin;
    public Vector2 offsetMax;

    public Quaternion rot;
    public Vector3 scale;
}

RawImageInfo originalImgInfo;
bool fullSclreen = false;

void Awake()
{
    //Get the default RawImage RectTransform settings
    originalImgInfo = GetImageSettings(image);
}

void Update()
{
    //Toggle fullscreen when Space key is pressed
    if (Input.GetKeyDown(KeyCode.Space))
    {
        //Toggle
        fullSclreen = !fullSclreen;
        if (fullSclreen)
            StretchImageFullScreen(image, 90);
        else
            ApplyImageSettings(image, originalImgInfo);
    }

    //Restore RawImage default settings when R key is pressed
    if (Input.GetKeyDown(KeyCode.R))
    {
        ApplyImageSettings(image, originalImgInfo);
        fullSclreen = false;
    }
}

private void StretchImageFullScreen(RawImage rawImage, int rotAngle = 0)
{
    RectTransform rectTrfm = rawImage.rectTransform;

    //Get angle and change z-axis
    Vector3 rot = rectTrfm.rotation.eulerAngles;
    rot.z = rotAngle; //Set Z rotation to rotAngle
    rectTrfm.rotation = Quaternion.Euler(rot);

    //Get current angle after changing it
    rot = rectTrfm.rotation.eulerAngles;

    if (Mathf.Approximately(rot.z, 0) || Mathf.Approximately(rot.z, 180))
    {
        rectTrfm.anchoredPosition3D = new Vector3(0, 0, 0);
        //Stretch the Image so that the whole screen is totally covered
        rectTrfm.anchorMin = new Vector2(0, 0);
        rectTrfm.anchorMax = new Vector2(1, 1);
        rectTrfm.pivot = new Vector2(0.5f, 0.5f);
        rectTrfm.offsetMin = Vector2.zero;
        rectTrfm.offsetMax = Vector2.zero;
    }

    else if (Mathf.Approximately(rot.z, -90) || Mathf.Approximately(rot.z, 90)
         || Mathf.Approximately(rot.z, 270))
    {

        //Get the Canvas RectTransform
        RectTransform canvasRectTrfm = rawImage.canvas.GetComponent<RectTransform>();
        float aspRatio = canvasRectTrfm.rect.size.x / canvasRectTrfm.rect.size.y;
        float halfAspRatio = aspRatio / 2.0f;
        float halfAspRatioInvert = (1.0f / aspRatio) / 2.0f;

        rectTrfm.anchorMin = new Vector2(0.5f - halfAspRatioInvert, 0.5f - halfAspRatio);
        rectTrfm.anchorMax = new Vector2(0.5f + halfAspRatioInvert, 0.5f + halfAspRatio);
        rectTrfm.anchoredPosition3D = Vector3.zero;
        rectTrfm.pivot = new Vector2(0.5f, 0.5f);
        rectTrfm.offsetMin = Vector2.zero;
        rectTrfm.offsetMax = Vector2.zero;
    }
}

RawImageInfo GetImageSettings(RawImage rawImage)
{
    RectTransform rectTrfm = rawImage.rectTransform;

    RawImageInfo rawImgInfo = new RawImageInfo();

    //Get settings from RawImage and store as RawImageInfo
    rawImgInfo.anchorPos = rectTrfm.anchoredPosition3D;
    rawImgInfo.widthAndHeight = rectTrfm.sizeDelta;

    rawImgInfo.anchorMin = rectTrfm.anchorMin;
    rawImgInfo.anchorMax = rectTrfm.anchorMax;
    rawImgInfo.pivot = rectTrfm.pivot;

    rawImgInfo.offsetMin = rectTrfm.offsetMin;
    rawImgInfo.offsetMax = rectTrfm.offsetMax;

    rawImgInfo.rot = rectTrfm.rotation;
    rawImgInfo.scale = rectTrfm.localScale;

    return rawImgInfo;
}

private void ApplyImageSettings(RawImage rawImage, RawImageInfo rawImgInfo)
{
    RectTransform rectTrfm = rawImage.rectTransform;

    //Apply settings from RawImageInfo to RawImage RectTransform
    rectTrfm.anchoredPosition3D = rawImgInfo.anchorPos;
    rectTrfm.sizeDelta = rawImgInfo.widthAndHeight;

    rectTrfm.anchorMin = rawImgInfo.anchorMin;
    rectTrfm.anchorMax = rawImgInfo.anchorMax;
    rectTrfm.pivot = rawImgInfo.pivot;

    rectTrfm.offsetMin = rawImgInfo.offsetMin;
    rectTrfm.offsetMax = rawImgInfo.offsetMax;

    rectTrfm.rotation = rawImgInfo.rot;
    rectTrfm.localScale = rawImgInfo.scale;
}