public CaptureManager(
			Resolution resolution,
  			bool captureImages,
		    bool captureAudio,
		    bool captureVideo,
		    CameraType cameraType,
		    string movieRecordingDirectory,
		    int movieSegmentDurationInMilliSeconds,
		    bool breakMovieIntoSegments )
		{
			this.resolution = resolution;
  			this.captureImages = captureImages;
		    this.captureAudio = captureAudio;
		    this.captureVideo = captureVideo;
			this.cameraType = cameraType;
			this.movieSegmentDurationInMilliSeconds = movieSegmentDurationInMilliSeconds;
			this.breakMovieIntoSegments = breakMovieIntoSegments;
			if ( captureAudio || captureVideo )
			{
			    this.movieRecordingDirectory =  Path.Combine( movieRecordingDirectory, getDateTimeDirectoryName( DateTime.Now ) );
				if ( Directory.Exists( this.movieRecordingDirectory ) == false )
				{
					Directory.CreateDirectory( this.movieRecordingDirectory );
				}
			}
		}

	/// <summary>
	/// Draw the custom wizard.
	/// </summary>

	void OnGUI ()
	{
		EditorGUIUtility.LookLikeControls(80f);

		GUILayout.Label("Create a new UI with the following parameters:");
		NGUIEditorTools.DrawSeparator();

		GUILayout.BeginHorizontal();
		NGUISettings.layer = EditorGUILayout.LayerField("Layer", NGUISettings.layer, GUILayout.Width(200f));
		GUILayout.Space(20f);
		GUILayout.Label("This is the layer your UI will reside on");
		GUILayout.EndHorizontal();

		GUILayout.BeginHorizontal();
		camType = (CameraType)EditorGUILayout.EnumPopup("Camera", camType, GUILayout.Width(200f));
		GUILayout.Space(20f);
		GUILayout.Label("Should this UI have a camera?");
		GUILayout.EndHorizontal();

		NGUIEditorTools.DrawSeparator();
		GUILayout.BeginHorizontal();
		EditorGUILayout.PrefixLabel("When ready,");
		bool create = GUILayout.Button("Create Your UI", GUILayout.Width(120f));
		GUILayout.EndHorizontal();

		if (create) CreateNewUI();
	}

        /// <summary>
        /// Initializes a new instance of the <see cref="BasicCamera"/> class.
        /// </summary>
        /// <param name="cameraType">Type of the camera device to use.</param>
        /// <param name="captureUse">The desired usage of the camera capture device.</param>
        protected BasicCamera(CameraType cameraType, CaptureUse captureUse)
        {
            this.CameraController = new CameraController(cameraType, captureUse);
            this.TaskEngine       = new CameraTaskEngine();

            this.CameraController.FocusChanged += this.CameraControllerOnFocusChanged;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CameraController"/> class.
        /// </summary>
        /// <param name="cameraType">Type of the camera device to use.</param>
        /// <param name="captureUse">The desired usage of the camera capture device.</param>
        /// <exception cref="ArgumentException"><paramref name="cameraType"/> is not supported.</exception>
        public CameraController(CameraType cameraType, CaptureUse captureUse)
        {
            this.CameraType = cameraType;
            this.CaptureUse = captureUse;

            this.ResetCaptureDevice(notifyProperties: false);
        }

        /// <summary>
        /// 摄像机。
        /// </summary>
        /// <param name="cameraType">类型</param>
        /// <param name="width">OpenGL窗口的宽度</param>
        /// <param name="height">OpenGL窗口的高度</param>
        public Camera(CameraType cameraType, double width, double height)
        {
            this.lastWidth = width;
            this.lastHeight = height;

            IPerspectiveCamera perspectiveCamera = this;
            perspectiveCamera.FieldOfView = 60.0f;
            perspectiveCamera.AspectRatio = width / height;
            perspectiveCamera.Near = 0.01;
            perspectiveCamera.Far = 10000;

            const int factor = 100;
            IOrthoCamera orthoCamera = this;
            orthoCamera.Left = -width / 2 / factor;
            orthoCamera.Right = width / 2 / factor;
            orthoCamera.Bottom = -height / 2 / factor;
            orthoCamera.Top = height / 2 / factor;
            orthoCamera.Near = -10000;
            orthoCamera.Far = 10000;

            this.Target = defaultTarget;
            this.Position = defaultPosition;
            this.UpVector = defaultUpVector;

            this.CameraType = cameraType;
        }

	/// <summary>
	/// Draw the custom wizard.
	/// </summary>

	void OnGUI ()
	{
		NGUIEditorTools.SetLabelWidth(80f);

		GUILayout.Label("Create a new UI with the following parameters:");
		NGUIEditorTools.DrawSeparator();

		GUILayout.BeginHorizontal();
		NGUISettings.layer = EditorGUILayout.LayerField("Layer", NGUISettings.layer, GUILayout.Width(200f));
		GUILayout.Space(20f);
		GUILayout.Label("This is the layer your UI will reside on");
		GUILayout.EndHorizontal();

		GUILayout.BeginHorizontal();
		camType = (CameraType)EditorGUILayout.EnumPopup("Camera", camType, GUILayout.Width(200f));
		GUILayout.Space(20f);
		GUILayout.Label("Should this UI have a camera?");
		GUILayout.EndHorizontal();

		NGUIEditorTools.DrawSeparator();
		GUILayout.BeginHorizontal();
		EditorGUILayout.PrefixLabel("When ready,");
		bool create = GUILayout.Button("Create Your UI", GUILayout.Width(120f));
		GUILayout.EndHorizontal();

		if (create) CreateNewUI(camType);

		EditorGUILayout.HelpBox("This tool has become obsolete with NGUI 3.0.6. You can create UIs from the NGUI -> Create menu.", MessageType.Warning);
	}

 public ThermoCam(SerializationInfo info, StreamingContext ctxt)
 {
     this._name          = (string)          info.GetValue("Nombre"   , typeof(string));
     this._address       = (string)          info.GetValue("Address"  , typeof(string));
     this._camType       = (CameraType)      info.GetValue("CamType"  , typeof(CameraType));
     this._devType       = (DeviceType)      info.GetValue("DevType"  , typeof(DeviceType));
     this._interfaceType = (InterfaceType)   info.GetValue("InterType", typeof(InterfaceType));
     this.SubZonas       = (List<SubZona>)   info.GetValue("SubZonas" , typeof(List<SubZona>));
 }

 public static ICamera CreateCamera(Game game, CameraType cameraType)
 {
     switch (cameraType)
     {
         case CameraType.FlightCamera: return new BasicCamera(game);
         case CameraType.FreeLookCamera: return new FreeLookCamera(game);
         default: throw new Exception();
     }
 }

 public CameraManager(GameScreen parent, CameraType cameraType, CameraSettings settings)
     : base(parent)
 {
     Settings = settings;
     Engine.Services.RegisterService(typeof(CameraManager), this);
     Viewport = Engine.GraphicsDevice.Viewport;
     Input = (Input)Engine.Services.GetService(typeof(Input));
     SetCamera(cameraType);
 }

 public static ICamera Get(CameraType type)
 {
     switch (type)
     {
         case CameraType.Usb: return new UsbCamera(); //If using webcam
         case CameraType.Ip: return new IpCamera(); //If using D-LINK DCS930 or DCS932
         default: throw new ArgumentNullException("Camera Type not supported. Set Camera Type in Settings.");
     }
 }

        public XNAKinectCatalogCamera(Game1 game, CameraType type)
            : base(game)
        {
            _gameInstance = game;

            // Subscribe this as a game service to be accesible from the entire application
            game.Services.AddService(typeof(XNAKinectCatalogCamera), this);

            _cameraType = type;
        }

 void CameraCheckingTouch()
 {
     if (Input.touchCount >= 3)
     {
         if (Input.GetTouch(2).phase == TouchPhase.Ended)
         {
             camtype = (CameraType)(((int)camtype + 1) % 3);
             CameraSwitch();
         }
     }
 }

        /// <summary>
        /// Gets the settings for the <paramref name="cameraType"/> specified.
        /// </summary>
        /// <param name="cameraType">Type of the camera to get settings for.</param>
        /// <returns>Settings for the <paramref name="cameraType" /> specified.</returns>
        public ICameraSettings GetCameraSettings(CameraType cameraType)
        {
            lock (this.cameraSettingsMap)
            {
                if (!this.cameraSettingsMap.ContainsKey(cameraType))
                {
                    this.cameraSettingsMap[cameraType] = new CameraSettings(cameraType);
                }

                return this.cameraSettingsMap[cameraType];
            }
        }

 public void SetCameraType(CameraType type, bool animated = false)
 {
     switch (type)
     {
     case CameraType.FirstPerson:
         SetFirstPersonCamera(animated);
         break;
     case CameraType.ThirdPerson:
         SetThirdPersonCamera(animated);
         break;
     }
 }

 void CameraCheckingPC()
 {
     if (Input.GetKeyDown(KeyCode.RightArrow))
     {
         camtype = (CameraType)(((int)camtype + 1) % 3);
         CameraSwitch();
     }
     if (Input.GetKeyDown(KeyCode.LeftArrow))
     {
         camtype = ((camtype - 1) < 0 ? camtype = CameraType.Copter : camtype--);
         CameraSwitch();
     }
 }

 public void SwitchCameraTo(CameraType cam)
 {
     for(int i = 0; i < (int)CameraType.size; i++)
     {
         if( i == (int)cam)
         {
             cameras[i].GetComponent<Camera>().enabled = true;
         } else
         {
             cameras[i].GetComponent<Camera>().enabled = false;
         }
     }
 }

 void LoadShooter(CameraType type)
 {
     primaryShooter = new CameraShooter(type);
     primaryCapture.Children.Add(primaryShooter);
     Canvas.SetLeft(primaryShooter, 5);
     Canvas.SetTop(primaryShooter, 5);
     primaryShooter.InitWidth = 600;
     primaryShooter.InitHeight = 0.75 * primaryShooter.InitWidth;
     primaryShooter.ListenTap();
     primaryShooter.Captured += primaryShooter_Captured;
     primaryShooter.Initialized += primaryShooter_Initialized;
     primaryShooter.Start();
 }

        public Camera(Point3D offset, Size resolution, Rectangle drawLocation, CameraType cameraStyle)
        {
            this.Offset = offset;

            this.CameraScreen = new Bitmap(resolution.Width, resolution.Height);

            this.DrawLocation = drawLocation;

            this.StartZDraw = 0;
            this.EndZDraw = 20;

            this.CameraStyle = cameraStyle;

            this.ShowBackground = true;
        }

 public NxCamera(Viewport v,Vector3 pos,Vector3 target,CameraType t)
 {
     mTgt = target;
     mPos = pos;
     mType = t;
     mType = CameraType.Targeted;
     mFov = 45;
     mClipNear = 1;
     mClipFar = 20000;
     mProjection = Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians( mFov),
         v.AspectRatio, mClipNear, mClipFar);
     if (mType == CameraType.Targeted)
         mView = Matrix.CreateLookAt(mPos, mTgt, Vector3.Up);
     else
         mView = Matrix.CreateTranslation(pos);
 }

        public static CompositeTransform GetCameraTransformByOrientation(CameraType cameraType, PageOrientation orientation)
        {
            var scaleX = 1;
            var scaleY = 1;
            var rotation = 0;

            if (cameraType == CameraType.FrontFacing)
            {
                scaleX = -1;
                if (orientation == PageOrientation.LandscapeRight)
                {
                    rotation = 180;
                }
                else if (orientation == PageOrientation.LandscapeLeft)
                {
                }
                else if (orientation == PageOrientation.PortraitUp)
                {
                    rotation = 90;
                }
            }
            else
            {
                if (orientation == PageOrientation.LandscapeRight)
                {
                    scaleX = -1;
                    scaleY = -1;
                }
                else if (orientation == PageOrientation.LandscapeLeft)
                {
                    // all good
                }
                else if (orientation == PageOrientation.PortraitUp)
                {
                    rotation = 90;
                }
            }

            return new CompositeTransform
            {
                CenterX = 0.5, 
                CenterY = 0.5, 
                ScaleX = scaleX, 
                ScaleY = scaleY, 
                Rotation = rotation 
            };
        }