void Start()
 {
     mCamera = new WebCamTexture ();
     mCamera.Play ();
     gameObject.GetComponent<Renderer> ().material.mainTexture = mCamera;
     if(!mCamera.isPlaying) mCamera.Play ();
 }

 // Use this for initialization
 void Start()
 {
     webcam = new WebCamTexture();
        GetComponent<Renderer>().material.mainTexture = webcam;
        webcam.Play();
     //webcam.videoVerticallyMirrored
 }

    // Use this for initialization
    void Start()
    {
        WebCamDevice[] devices = WebCamTexture.devices;
        // display all cameras
        for (var i = 0; i < devices.Length; i++) {
            Debug.Log (devices [i].name);
        }

        imageObj = GameObject.Find("RawImage").gameObject as GameObject;

        string deviceName = devices [0].name;
        foreach (var device in WebCamTexture.devices) {
            if (device.isFrontFacing) {
                deviceName = device.name;
            }
        }

        webcamTexture = new WebCamTexture(deviceName, Width, Height, FPS);

        if (webcamTexture == null) {
            Debug.Log (webcamTexture);
        }
        webcamTexture.Play();

        imageObj.GetComponent<RawImage>().texture = webcamTexture;
    }

 // Use this for initialization
 void Start()
 {
     // load image from camera
     back = new WebCamTexture ();
     renderer.material.mainTexture = back;
     back.Play ();
 }

 void Awake()
 {
     WebCamTexture webcam=new WebCamTexture();
     imagen.texture = webcam;
     imagen.material.mainTexture=webcam;
     webcam.Play();
 }

 public static void Init(string deviceName, int requestedWidth, int requestedHeight, int requestedFps, BitDepth targetBitDepth)
 {
     WebCamTexture = new WebCamTexture(deviceName, requestedWidth, requestedHeight, requestedFps);
     WebCamTexture.Play();
     if (!WebCamTextureProxy.instance)
         new GameObject("_webcamtextureproxy") { hideFlags = HideFlags.HideAndDontSave }.AddComponent<WebCamTextureProxy>().SetTargetTexture(WebCamTexture).SetTargetDepth(targetBitDepth).StartCapture();
 }

 void Start()
 {
     WebCamTexture webcamTexture = new WebCamTexture();
     rawimage.texture = webcamTexture;
     rawimage.material.mainTexture = webcamTexture;
     webcamTexture.Play();
 }

    public void SetWebCamTexture(int w, int h, int f)
    {
        width = w;
        height = h;
        fps = f;

        if(Application.isPlaying){

            if( null != webcam ) {
                webcam.Stop();
                Destroy(webcam);
            }

            webcam = new WebCamTexture(w, h, f);

            if(targetMaterial == null) {
                targetMaterial = renderer.material;
            }

            if(texturePropertyName == null || texturePropertyName.Length == 0) {
                targetMaterial.mainTexture = webcam;
            } else {
                targetMaterial.SetTexture(texturePropertyName, webcam);
            }

            webcam.Play();
        }
    }

	void Awake()
	{
		//setup unity webcam
		WebCamDevice[] devices= WebCamTexture.devices;
		if (devices.Length <= 0){
			Debug.LogError("No Webcam.");
			return;
		}
		WebCamTexture w=new WebCamTexture(320,240,15);
		//Make WebcamTexture wrapped Sensor.
		this._ss=NyARUnityWebCam.createInstance(w);
		//Make configulation by Sensor size.
		NyARMarkerSystemConfig config = new NyARMarkerSystemConfig(this._ss.width,this._ss.height);

		this._ms=new NyARUnityMarkerSystem(config);
		mid=this._ms.addARMarker(
			new StreamReader(new MemoryStream(((TextAsset)Resources.Load("patt_hiro",typeof(TextAsset))).bytes)),
			16,25,80);
		//setup background
		this._bg_panel=GameObject.Find("Plane");
		this._bg_panel.renderer.material.mainTexture=w;
		this._ms.setARBackgroundTransform(this._bg_panel.transform);
		
		//setup camera projection
		this._ms.setARCameraProjection(this.camera);
		GameObject.Find("Cube").renderer.material.mainTexture=new Texture2D(64,64);
	}	

    // Use this for initialization
    void Start()
    {
        var devices = WebCamTexture.devices;
        if ( devices.Length == 0 ) {
            Debug.LogError( "Webカメラが検出できませんでした。" );
            return;
        }

        // WebCamテクスチャを作成する
        var webcamTexture = new WebCamTexture( Width, Height, FPS );
        renderer.material.mainTexture = webcamTexture;
        webcamTexture.Play();

        // ミラーリング
        if ( Mirror ) {
            transform.localScale = new Vector3( -transform.localScale.x, transform.localScale.y, transform.localScale.z );
        }

        // 縦にする
        if ( RightUp ) {
            var euler = transform.localRotation.eulerAngles;
            transform.localRotation = Quaternion.Euler( euler.x, euler.y, euler.z + 90 );
        }
        else if ( LeftUp ) {
            var euler = transform.localRotation.eulerAngles;
            transform.localRotation = Quaternion.Euler( euler.x, euler.y, euler.z - 90 );
        }
    }

 // Use this for initialization
 void Start()
 {
     var wc = new WebCamTexture (640, 400);
     wc.Play ();
     Shader.SetGlobalTexture (propEmit, wc);
     Shader.SetGlobalTexture (propKage, wc);
 }

    /// <summary>
    /// 
    /// </summary>
    void Start()
    {
        webcamTexture = new WebCamTexture();

        matWeb.mainTexture = webcamTexture;
        webcamTexture.Play();
    }

    void Awake()
    {
        m_ProjectionCam = GameObject.Find("Projection Camera");
        m_TopDownCam = GameObject.Find("Top Down Camera");
        m_GUICam = GameObject.Find("GUI Camera");

        //3 screens 5 monitors
        if(Application.isEditor)
            m_fEditorValue = 6079;
        else
            m_fEditorValue = (float)Screen.width;

        m_fGUICamProWidth = 1280.0f / m_fEditorValue;
        m_fProjCamProStart = 2560.0f / m_fEditorValue;
        m_fProjCamProWidth = (m_fEditorValue - 2560) / m_fEditorValue;

        m_GUICam.camera.rect = new Rect(0.0f, 0, m_fGUICamProWidth, 1);
        m_TopDownCam.camera.rect = new Rect(m_fGUICamProWidth, 0, m_fGUICamProWidth, 1);
        m_ProjectionCam.camera.rect = new Rect(m_fProjCamProStart, 0, m_fProjCamProWidth, 1);

        //webcam
        webcamTexture = new WebCamTexture();
        webcamTexture.requestedWidth = (int)(Screen.width / 4) / 3;
        webcamTexture.requestedHeight = (int)(Screen.height / 1.333333) / 3;
        //webcamTexture.Play();

        m_WebRect = new Rect();

        m_WebRect.x = Screen.width * m_TopDownCam.camera.rect.x;
        m_WebRect.y = Screen.height - ((Screen.height / 1.333333f) / 3);
        m_WebRect.width = (Screen.width * m_TopDownCam.camera.rect.width) / 3;
        m_WebRect.height = (Screen.height / 1.333333f) / 3;
    }

    //TextBox
    ////private TouchKeyboard m_TouchKeyboard =  new TouchKeyboard();
    //string[] m_TextBoxStrings;
    //int m_iFocusOn;
    //bool m_bFocusChange;
    void Awake()
    {
        m_ProjectionCam = GameObject.Find("Projection Camera");
        m_TopDownCam = GameObject.Find("Top Down Camera");
        m_GUICam = GameObject.Find("GUI Camera");

        m_Resolution = m_MainResolution;

        //Setup the cameras depending on settings
        SetupCameras();

        //Screen.SetResolution((int)m_Resolution.x, (int)m_Resolution.y, true);
        //Screen.fullScreen = true;
        m_GUIGroupRect = new Rect((Screen.width * m_GUICam.camera.rect.x), 0, 1280, 960);

        //webcam
        webcamTexture = new WebCamTexture();
        webcamTexture.requestedWidth = (int)(Screen.width / 4) / 3;
        webcamTexture.requestedHeight = (int)(Screen.height / 1.333333) / 3;
        //webcamTexture.Play();

        m_WebRect = new Rect();

        m_WebRect.x = Screen.width * m_TopDownCam.camera.rect.x;
        m_WebRect.y = Screen.height - ((Screen.height / 1.333333f) / 3);
        m_WebRect.width = (Screen.width * m_TopDownCam.camera.rect.width) / 3;
        m_WebRect.height = (Screen.height / 1.333333f) / 3;
    }

    void Start()
    {
        // Checks how many and which cameras are available on the device
        for (int cameraIndex = 0; cameraIndex < WebCamTexture.devices.Length; cameraIndex++)
        {
            // We want the back camera
            if (!WebCamTexture.devices[cameraIndex].isFrontFacing)
            {
                webCameraTexture = new WebCamTexture(cameraIndex, Screen.width, Screen.height);

                // Here we flip the GuiTexture by applying a localScale transformation
                // works only in Landscape mode
                myCameraTexture.transform.localScale = new Vector3(-1,-1,1);
            }

        }

        // Here we tell that the texture of coming from the camera should be applied
        // to our GUITexture. As we have flipped it before the camera preview will have the
        // correct orientation
        myCameraTexture.texture = webCameraTexture;

        // Starts the camera
        webCameraTexture.Play();
    }

 void Start ()
 {
     webcamTexture = new WebCamTexture();
     Renderer renderer = GetComponent<Renderer>();
     renderer.material.mainTexture = webcamTexture;
     OnEnable();
 }

    void Update()
    {
        // Control luminance treshold
        if (Input.GetKey(KeyCode.RightArrow)) {
            treshold = Mathf.Clamp(treshold + 0.001f, 0f, 1f);
        } else if (Input.GetKey(KeyCode.LeftArrow)) {
            treshold = Mathf.Clamp(treshold - 0.001f, 0f, 1f);
        }

        // Control fade out ratio
        if (Input.GetKey(KeyCode.DownArrow)) {
            fadeOutRatio = Mathf.Clamp(fadeOutRatio - 0.001f, 0f, 1f);
        } else if (Input.GetKey(KeyCode.UpArrow)) {
            fadeOutRatio = Mathf.Clamp(fadeOutRatio + 0.001f, 0f, 1f);
        }

        // Switch camera
        if (Input.GetKeyDown(KeyCode.C)) {
            if (WebCamTexture.devices.Length > 1) {
                currentWebcam = (currentWebcam + 1) % WebCamTexture.devices.Length;
                textureWebcam.Stop();
                textureWebcam = new WebCamTexture(WebCamTexture.devices[currentWebcam].name);
                Shader.SetGlobalTexture("_TextureWebcam", textureWebcam);
                textureWebcam.Play();
            }
        }

        if (Input.anyKey) {
            UpdateUniforms();
        }
    }

	void Awake()
	{
		//setup unity webcam
		WebCamDevice[] devices= WebCamTexture.devices;
		if (devices.Length<=0){
			Debug.LogError("No Webcam.");
			return;
		}
		WebCamTexture w=new WebCamTexture(320,240,15);
		//Make WebcamTexture wrapped Sensor.
		this._ss=NyARUnityWebCam.createInstance(w);
		//Make configulation by Sensor size.
		NyARMarkerSystemConfig config = new NyARMarkerSystemConfig(this._ss.width,this._ss.height);

		this._ms=new NyARUnityMarkerSystem(config);
		//mid=this._ms.addARMarker("./Assets/Data/patt.hiro",16,25,80);
		//This line loads a marker from texture
		mid=this._ms.addARMarker((Texture2D)(Resources.Load("MarkerHiro", typeof(Texture2D))),16,25,80);

		//setup background
		this._bg_panel=GameObject.Find("Plane");
		this._bg_panel.renderer.material.mainTexture=w;
		this._ms.setARBackgroundTransform(this._bg_panel.transform);
		
		//setup camera projection
		this._ms.setARCameraProjection(this.camera);
		return;
	}

    // Use this for initialization
    void Start()
    {
        // Ensure orientation and scaling of the image.
        var scale = 2.2f;
        Quaternion rotation = Quaternion.Euler(0, 0, 0);
        Matrix4x4 rotationMatrix = Matrix4x4.TRS(Vector3.zero, rotation, new Vector3(scale , scale , scale));
        gameObject.GetComponent<Renderer>().material.SetMatrix("_Rotation", rotationMatrix);

        int t = 0;
        bool front_facing = false;

        WebCamDevice[] devices = WebCamTexture.devices;

        // Gets the back facing camera if there is one on the device
        while(front_facing && t < devices.Length){
            deviceName = devices[t].name;
            front_facing = devices[t].isFrontFacing;
            t++;
        }

        webcamTexture = new WebCamTexture(deviceName);

        // performs the vertical axis flip
        if (!front_facing) {
            transform.Rotate(new Vector3(0,0,180));
        }

        // performs the horizontal axis flip that is the issue regardless
        transform.localScale = new Vector3(-1 * transform.localScale.x,
                                           transform.localScale.y,
                                           transform.localScale.z);

        GetComponent<Renderer>().material.mainTexture = webcamTexture;
        webcamTexture.Play();
    }

	void LoadConfigs(){
		webcamTexture = new WebCamTexture (480, 320, 30);
		
		myURL = Config.masterURL;
		fileName = Config.currentChild;
		totalMemories = Config.currentChildDayMemoriesCount;

		Debug.Log ("Total memories: " + totalMemories);
		
		myURL += "?webfilename=" + fileName +
			"&webusername=" + Config.masterUser +
				"&webpassword=" + Config.masterPass;
		
		memoryDay = Config.currentDay;
		memoryMonth = Config.currentMonth;
		memoryYear = Config.currentYear;

		NGUITools.SetActive (confirmButton, false);

		titleUILabel.value = "";
		descriptionUILabel.value = "";

		photoUITexture.mainTexture = null;
		
#if UNITY_EDITOR
		webcamTexture = new WebCamTexture ();
		photoUITexture.mainTexture = webcamTexture;
		webcamTexture.Play ();
#endif
#if UNITY_IOS
		PromptForPhoto ();
#endif
	}