高通AR加视屏解决方案

来源：互联网发布：如何下载会声会影软件编辑：程序博客网时间：2024/05/16 02:22

按到以下教程制作出现以下问题

1、视频不能播放

解决方案：1、加入SceneManager 2、给ARCamera加上PlayVideo.cs

问题2：勾选auto play后，还是不能自动播放

解决方案：给ImageTarget 加上 TrackableEventHandler.cs

2、加入SceneManager了后，在启动软件时有高通的介绍和设置之类的，要取消的话在代码中改,注销红色部分即可

AppManager.cs

public virtual void InitManager()
    {
        mSplashView = new SplashScreenView();
        mAboutView = new AboutScreenView();
        mAboutView.SetTitle(TitleForAboutPage);
        mAboutView.OnStartButtonTapped += OnAboutStartButtonTapped;
        m_UIEventHandler.CloseView += OnTappedOnCloseButton;
        m_UIEventHandler.GoToAboutPage += OnTappedOnGoToAboutPage;
        InputController.SingleTapped += OnSingleTapped;
        InputController.DoubleTapped += OnDoubleTapped;
        InputController.BackButtonTapped += OnBackButtonTapped;

        //mSplashView.LoadView();
        //StartCoroutine(LoadAboutPageForFirstTime());
        mActiveViewType = ViewType.SPLASHVIEW;
    }

前段时间忙公司的事，好久没到CSDN来了，看到教程有这么多人参考，决心再接再厉，这篇教程就讲讲怎么做video形式的增强现实。（自己做了个案例，少女时代著名的甩大腿舞戳我O(∩_∩)O）

高通的SDK好像没有video的预制件，所以我一般都下载最新的samples，里面有我们需要用到的预制件。高通官网下载：

将包导入unity，大家可以选择自行研究例子，理清制作思路，当然也可以直接利用我总结出来的方法制作。

1、和之前介绍的AR制作一样，首先删掉main camera，在Assets搜索AR Camera并将其拖到Hierarchy，同样的将ImageTarget也拖进来，对ImageTarget参数进行修改，这里我使用例子里的识别图。

2、在assets里找到video这个预制件，将他拖到imagetarget下作为子物体。

3、修改video的参数，path是视频的名字加后缀，例如：VuforiaSizzleReel_1.m4v，因为视频一般较大，所以建议大家将视频格式转为3g2，可以大大压缩视频所占空间，唯一的缺点是不能在电脑上测试。

4、最重要的问题，vuforia如何找到视频的路径？答案是，视频必须放在指定文件夹下，当然可以到代码修改文件夹。默认的是StreamingAssets文件夹下

5、其他的操作，如需控制视频播放，比如识别图移出摄像头，然后再次识别，视频是从头开始播放还是从上一次的位置播放呢？大家自行阅读VideoPlaybackBehaviour这个脚本，然后修改代码就可以了~\(≧▽≦)/~啦啦啦

以上教程原地址：http://blog.csdn.net/dzyi_/article/details/34847339

按照原作者的想法，是可以实现手机观察到播放封面，但没法点击播放。针对这个问题，我翻看了官方论坛，因为最新的unity包缺少了一个C#文件。把缺少的文件加上，可以实现播放，以下为详细说明：

The objective here is to show how to replicate the essence of the Vuforia-VideoPlayback sample scene using the Vuforia prefabs and the drag and drop approach of Unity:

Create a new Unity project
Import the Vuforia video playback unity package
Create a new scene
Drag the ARCamera prefab into the Unity scene
Under the DataSetLoadBehaviour in the Inspector tick “Load Data Set StonesAndChips”, and the 'Activate' checkbox below this
From '/Qualcomm AugmentedReality/Prefabs' drag the ImageTarget prefab into the scene
- For the Image Target select “StonesAndChips” as the dataset and the Image Target should change to the Stones texture
From Vuforia Video Playback/Prefabs drag the Video prefab to be the child of the Image Target
- In the Inspector under “Video Playback Behaviour (Script)” set the path to 'VuforiaSizzleReel_1.m4v'
Drag the TrackableEventHandler from Scripts to the Image Target (this plays the video)
Remove the DefaultTrackableEventHandler script from the Image Target as it is not needed.
Autoplay works already, however tapping the video does not yet work. In order to fix this, simply create a VideoPlaybackController script, fill it with the code below, and then attach this to the ARCamera.

大概意思就是（我英语不好，懂意思就好= =#，英语好的还是读上文吧）：

创建一个新的Unity工程
引入Vuforia video playback的unity包
创建一个新的场景
拖ARCamera进场景（ARCamera搜索下很好找到）
点击场景中的ARCamera，右边Inspector栏目，DataSetLoadBehaviour（script）中“Load Data Set StonesAndChips”和 'Activate'都打上勾
从'/Qualcomm AugmentedReality/Prefabs'目录中Image Target拖入场景，右边Data Set选择“StonesAndChips”
从“Vuforia Video Playback/Prefabs”目录中Video拖入场景，右边“Video Playback Behaviour (Script)”中path栏输入'VuforiaSizzleReel_1.m4v'（测试是播放这个视频），或者也可以使用
[html] view plaincopy
1. http://oneshot.qualcomm.com/webAR/content/strawberryfields_H264_AAC.mp4
这个网络视频进行测试
把TrackableEventHandler这个C#文件放到Image Target中，主要是用来播放视频的
从Image Target中移除DefaultTrackableEventHandler这个文件的使用，因为这个文件根本不需要，移除的话其实把它的打勾去掉也可以
自动播放要不要打上勾随自己需要，创建VideoPlaybackController的C#文件放入ARCamera中，VideoPlaybackController中的代码如下：

[csharp] view plaincopy
/*============================================================================== 
Copyright (c) 2012-2014 Qualcomm Connected Experiences, Inc. 
All Rights Reserved. 
  
This  Vuforia(TM) sample application in source code form ("Sample Code") for the 
Vuforia Software Development Kit and/or Vuforia Extension for Unity 
(collectively, the "Vuforia SDK") may in all cases only be used in conjunction 
with use of the Vuforia SDK, and is subject in all respects to all of the terms 
and conditions of the Vuforia SDK License Agreement, which may be found at 
<a title="https://developer.vuforia.com/legal/license" href="https://developer.vuforia.com/legal/license">https://developer.vuforia.com/legal/license</a>. 
  
By retaining or using the Sample Code in any manner, you confirm your agreement 
to all the terms and conditions of the Vuforia SDK License Agreement.  If you do 
not agree to all the terms and conditions of the Vuforia SDK License Agreement, 
then you may not retain or use any of the Sample Code in any manner. 
==============================================================================*/  
   
using UnityEngine;  
using System.Collections;  
   
/// <summary>  
/// This class contains the logic to handle taps on VideoPlaybackBehaviour game objects  
/// and starts playing the according video. It also pauses other videos when a new one is  
/// started.  
/// </summary>  
public class VideoPlaybackController : MonoBehaviour  
{  
    #region PRIVATE_MEMBER_VARIABLES  
   
    private Vector2 mTouchStartPos;  
    private bool mTouchMoved = false;  
    private float mTimeElapsed = 0.0f;  
   
    private bool mTapped = false;  
    private float mTimeElapsedSinceTap = 0.0f;  
   
    private bool mWentToFullScreen = false;  
  
    #endregion // PRIVATE_MEMBER_VARIABLES  
  
  
  
    #region UNITY_MONOBEHAVIOUR_METHODS  
   
    void Update()  
    {  
        // Determine the number of taps  
        // Note: Input.tapCount doesn't work on Android  
   
        if (Input.touchCount > 0)  
        {  
            Touch touch = Input.touches[0];  
            if (touch.phase == TouchPhase.Began)  
            {  
                mTouchStartPos = touch.position;  
                mTouchMoved = false;  
                mTimeElapsed = 0.0f;  
            }  
            else  
            {  
                mTimeElapsed += Time.deltaTime;  
            }  
   
            if (touch.phase == TouchPhase.Moved)  
            {  
                if (Vector2.Distance(mTouchStartPos, touch.position) > 40)  
                {  
                    // Touch moved too far  
                    mTouchMoved = true;  
                }  
            }  
            else if (touch.phase == TouchPhase.Ended)  
            {  
                if (!mTouchMoved && mTimeElapsed < 1.0)  
                {  
                    if (mTapped)  
                    {  
                        // Second tap  
                        HandleDoubleTap();  
                        mTapped = false;  
                    }  
                    else  
                    {  
                        // Wait to see if this is a double tap  
                        mTapped = true;  
                        mTimeElapsedSinceTap = 0.0f;  
                    }  
                }  
            }  
        }  
   
        if (mTapped)  
        {  
            if (mTimeElapsedSinceTap >= 0.5f)  
            {  
                // Not a double tap  
                HandleTap();  
                mTapped = false;  
            }  
            else  
            {  
                mTimeElapsedSinceTap += Time.deltaTime;  
            }  
        }  
   
        // special handling in play mode:  
        if (QCARRuntimeUtilities.IsPlayMode())  
        {  
            if (Input.GetMouseButtonUp(0))  
            {  
                if (PickVideo(Input.mousePosition) != null)  
                    Debug.LogWarning("Playing videos is currently not supported in Play Mode.");  
            }  
        }  
    }  
  
    #endregion // UNITY_MONOBEHAVIOUR_METHODS  
  
  
  
    #region PRIVATE_METHODS  
   
    /// <summary>  
    /// Handle single tap event  
    /// </summary>  
    private void HandleTap()  
    {  
        // Find out which video was tapped, if any  
        VideoPlaybackBehaviour video = PickVideo(mTouchStartPos);  
   
        if (video != null)  
        {  
            if (video.VideoPlayer.IsPlayableOnTexture())  
            {  
                // This video is playable on a texture, toggle playing/paused  
   
                VideoPlayerHelper.MediaState state = video.VideoPlayer.GetStatus();  
                if (state == VideoPlayerHelper.MediaState.PAUSED ||  
                    state == VideoPlayerHelper.MediaState.READY ||  
                    state == VideoPlayerHelper.MediaState.STOPPED)  
                {  
                    // Pause other videos before playing this one  
                    PauseOtherVideos(video);  
   
                    // Play this video on texture where it left off  
                    video.VideoPlayer.Play(false, video.VideoPlayer.GetCurrentPosition());  
                }  
                else if (state == VideoPlayerHelper.MediaState.REACHED_END)  
                {  
                    // Pause other videos before playing this one  
                    PauseOtherVideos(video);  
   
                    // Play this video from the beginning  
                    video.VideoPlayer.Play(false, 0);  
                }  
                else if (state == VideoPlayerHelper.MediaState.PLAYING)  
                {  
                    // Video is already playing, pause it  
                    video.VideoPlayer.Pause();  
                }  
            }  
            else  
            {  
                // Display the busy icon  
                video.ShowBusyIcon();  
                   
                // This video cannot be played on a texture, play it full screen  
                video.VideoPlayer.Play(true, 0);  
                mWentToFullScreen = true;  
            }  
        }  
    }  
   
   
    /// <summary>  
    /// Handle double tap event  
    /// </summary>  
    private void HandleDoubleTap()  
    {  
        // Find out which video was tapped, if any  
        VideoPlaybackBehaviour video = PickVideo(mTouchStartPos);  
   
        if (video != null)  
        {  
            if (video.VideoPlayer.IsPlayableFullscreen())  
            {  
                // Pause the video if it is currently playing  
                video.VideoPlayer.Pause();  
   
                // Seek the video to the beginning();  
                video.VideoPlayer.SeekTo(0.0f);  
   
                // Display the busy icon  
                video.ShowBusyIcon();  
   
                // Play the video full screen  
                video.VideoPlayer.Play(true, 0);  
                mWentToFullScreen = true;  
            }  
        }  
    }  
   
   
    /// <summary>  
    /// Find the video object under the screen point  
    /// </summary>  
    private VideoPlaybackBehaviour PickVideo(Vector3 screenPoint)  
    {  
        VideoPlaybackBehaviour[] videos = (VideoPlaybackBehaviour[])  
                FindObjectsOfType(typeof(VideoPlaybackBehaviour));  
   
        Ray ray = Camera.main.ScreenPointToRay(screenPoint);  
        RaycastHit hit = new RaycastHit();  
   
        foreach (VideoPlaybackBehaviour video in videos)  
        {  
            if (video.collider.Raycast(ray, out hit, 10000))  
            {  
                return video;  
            }  
        }  
   
        return null;  
    }  
   
   
    /// <summary>  
    /// Pause all videos except this one  
    /// </summary>  
    private void PauseOtherVideos(VideoPlaybackBehaviour currentVideo)  
    {  
        VideoPlaybackBehaviour[] videos = (VideoPlaybackBehaviour[])  
                FindObjectsOfType(typeof(VideoPlaybackBehaviour));  
   
        foreach (VideoPlaybackBehaviour video in videos)  
        {  
            if (video != currentVideo)  
            {  
                if (video.CurrentState == VideoPlayerHelper.MediaState.PLAYING)  
                {  
                    video.VideoPlayer.Pause();  
                }  
            }  
        }  
    }  
  
    #endregion // PRIVATE_METHODS  
  
  
  
    #region PUBLIC_METHODS  
   
    /// <summary>  
    /// One-time check for the Instructional Screen  
    /// </summary>  
    public bool CheckWentToFullScreen()  
    {  
        bool result = mWentToFullScreen;  
        mWentToFullScreen = false;  
        return result;  
    }  
  
    #endregion // PUBLIC_METHODS  
}  

2 0