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>
/// Create a brand-new UI hierarchy.
/// </summary>
static public GameObject CreateNewUI(CameraType type)
{
UIPanel p = NGUITools.CreateUI(type == CameraType.Advanced3D, NGUISettings.layer);
Selection.activeGameObject = p.gameObject;
return(Selection.activeGameObject);
}
public bxrCubemap GetCameraCubeMap( CameraType type )
{
if( type == CameraType.Left )
return left;
else
return right;
}
private static void LoadAsset(LOD lod, LODGroup lodGroup, float distance, CameraType type)
{
var handle = AssetLoadManager.Instance.LoadAsset(lod, lod.Address, lod.Priority, distance);
lod.Handle = handle;
handle.Completed += h =>
{
if (lod.CurrentState != State.Loading)
{
AssetLoadManager.Instance.UnloadAsset(h);
return;
}
if (h.Status == AsyncOperationStatus.Failed)
{
Debug.LogError("Failed to load asset: " + lod.Address);
h.Controller.CurrentState = State.Failed;
return;
}
// var go =Addressables.InstantiateAsync(h.Result, lodGroup.transform, false);
//
//
// Debug.Log(go.Result.name);
GameObject gameObject = GameObject.Instantiate(h.Result, lodGroup.transform, false);
h.Result = gameObject;
gameObject.transform.parent = lodGroup.transform;
h.Controller.CurrentState = State.Loaded;
lodGroup.OnDisableAllLOD(type);
};
lod.CurrentState = State.Loading;
}
/// <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.1;
perspectiveCamera.Far = 1000;
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 = -1000;
orthoCamera.Far = 1000;
this.Target = defaultTarget;
this.Position = defaultPosition;
this.UpVector = defaultUpVector;
this.CameraType = cameraType;
}
/// <summary>
///
/// </summary>
/// <param name="userName"></param>
/// <param name="password"></param>
/// <param name="level"></param>
/// <returns></returns>
public int addCameraType(string typeName)
{
int rct = -1;
try
{
CameraType mUser = getCameraTypeByName(typeName);
if (mUser == null)
{
if (!typeName.Equals(""))
{
rct = (int)this._sqlContext.Insert <DataBaseConfig.CameraType>(() => new DataBaseConfig.CameraType()
{
TypeName = typeName
});
}
}
}
catch (Exception ex)
{
rct = -1;
LogRecord.LogHelper.Exception(typeof(TCameraType), ex);
}
return(rct);
}
/// <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>
/// 摄像机。
/// </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;
}
} //END DestroyDuplicateInstance
//-------------------------------//
public void BeginLoadingTexture( CameraType cameraType, CubeSide cubeSide, ImageType imageType )
//-------------------------------//
{
SetLoadedBool( cameraType, cubeSide, false );
//if( showDebug ) { Debug.Log( "ImageFactory.cs BeginLoadingTexture() ( " + cameraType + ", " + cubeSide + ", " + imageType + " )" ); }
if( XRSkyboxManager.instance.loadFrom == XRSkyboxManager.LoadFrom.DictionaryTexture )
{
SetDictionaryLoadedTexture( cameraType, cubeSide, imageType );
}
else if( XRSkyboxManager.instance.loadFrom == XRSkyboxManager.LoadFrom.ResourcesTexture )
{
SetTextureFromResourcesTexture( cameraType, cubeSide, imageType );
}
else if( XRSkyboxManager.instance.loadFrom == XRSkyboxManager.LoadFrom.ResourcesBytes )
{
StartCoroutine( SetTextureFromResourcesBytes( cameraType, cubeSide, imageType ) );
}
else if( XRSkyboxManager.instance.loadFrom == XRSkyboxManager.LoadFrom.StreamingAssetsBytes )
{
StartCoroutine( SetTextureFromStreamingAssetsBytes( cameraType, cubeSide, imageType ) );
}
} //END BeginLoadingTexture
/// <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>
/// Gets all the <see cref="CameraType"/> and <see cref="Room"/> values for for the <see cref="Camera079"/> instances using <see cref="Camera079.cameraId"/> and <see cref="UnityEngine.GameObject"/> name.
/// </summary>
internal static void RegisterCameraInfoOnLevelLoad()
{
OrderedCameraTypes.Clear();
ReadOnlyCollection <Camera079> cameras = Map.Cameras;
int cameraCount = cameras.Count;
for (int i = 0; i < cameraCount; i++)
{
Camera079 camera = cameras[i];
int cameraID = camera.GetInstanceID();
CameraType cameraType = (CameraType)cameraID;
Room room = Map.FindParentRoom(camera.gameObject);
if (OrderedCameraTypes.ContainsKey(cameraID))
{
OrderedCameraTypes.Remove(cameraID);
}
if (OrderedCameraRooms.ContainsKey(cameraID))
{
OrderedCameraRooms.Remove(cameraID);
}
OrderedCameraTypes.Add(cameraID, cameraType);
OrderedCameraRooms.Add(cameraID, room);
}
}
/// <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 void SetCurrentCamera(CameraType camType)
{
CurrentCamera.gameObject.SetActive(false);
bool useDefault = true;
switch (camType)
{
case CameraType.Horizontal:
{
if (_horizontalCamera != null)
{
CurrentCamera = _horizontalCamera;
useDefault = false;
}
break;
}
}
if (useDefault)
{
CurrentCamera = _defaultCamera;
}
CurrentCamera.gameObject.SetActive(true);
MoveCurrentCamTo(CamPosition, true);
Debug.Log("Camera mode selected: " + CurrentCamera.name);
}
private void OnButtonEnvent()
{
//判断当前摄像头类型关闭当前协程切换成对应摄像头
if (cameraType == CameraType.BackCamera)
{
StopCoroutine("ToOpenCamera");
cameraType = CameraType.FrontCamera;
StartCoroutine(ToOpenCamera(cameraType));
//切换前后置摄像头需要镜像，不然拍摄左右会颠倒
// rawImage.transform.eulerAngles = new Vector3(0, 90, 0);
}
else
{
StopCoroutine("ToOpenCamera");
cameraType = CameraType.BackCamera;
StartCoroutine(ToOpenCamera(cameraType));
//切换前后置摄像头需要镜像回来，不然拍摄左右会颠倒
// rawImage.transform.eulerAngles = new Vector3(0, -90, 0);
}
}
//카메라 효과
void CameraEffect(CameraType cameraType)
{
Camera.main.fieldOfView = 60 + Mathf.Clamp(rigid.velocity.magnitude * 3, 0, 100);
switch (cameraType)
{
case CameraType.thirdPerson:
Camera.main.transform.localPosition = new Vector3(Mathf.Clamp(Input.GetAxis("Horizontal") * rigid.velocity.magnitude * 0.01f, -5, 5), effectinfo.thirdPersonCamera.localPosition.y, effectinfo.thirdPersonCamera.localPosition.z);
Camera.main.transform.rotation = effectinfo.thirdPersonCamera.rotation;
foreach (GameObject mirror in effectinfo.Mirrors)
{
mirror.SetActive(false);
}
break;
case CameraType.firstPerson:
Camera.main.transform.localPosition = effectinfo.firstPersonCamera.localPosition;
Camera.main.transform.rotation = effectinfo.firstPersonCamera.rotation;
foreach (GameObject mirror in effectinfo.Mirrors)
{
mirror.SetActive(true);
}
break;
}
}
} //END SetStreamingAssetsLoadedTexture
//-----------------------------//
private void SetLoadedTextureScaleAndSettings( CameraType cameraType, CubeSide cubeSide, TextureFormat format, bool useMipmap, int scaleX, int scaleY )
//-----------------------------//
{
if( cameraType == CameraType.Left )
{
if( cubeSide == CubeSide.front )
{
texture_Left_front = new Texture2D( scaleX, scaleY, format, useMipmap ); //, format, useMipmap );
}
else if( cubeSide == CubeSide.back )
{
texture_Left_back = new Texture2D( scaleX, scaleY, format, useMipmap );
}
else if( cubeSide == CubeSide.left )
{
texture_Left_left = new Texture2D( scaleX, scaleY, format, useMipmap );
}
else if( cubeSide == CubeSide.right )
{
texture_Left_right = new Texture2D( scaleX, scaleY, format, useMipmap );
}
else if( cubeSide == CubeSide.top )
{
texture_Left_top = new Texture2D( scaleX, scaleY, format, useMipmap );
}
else if( cubeSide == CubeSide.bottom )
{
texture_Left_bottom = new Texture2D( scaleX, scaleY, format, useMipmap );
}
}
else if( cameraType == CameraType.Right )
{
if( cubeSide == CubeSide.front )
{
texture_Right_front = new Texture2D( scaleX, scaleY, format, useMipmap );
}
else if( cubeSide == CubeSide.back )
{
texture_Right_back = new Texture2D( scaleX, scaleY, format, useMipmap );
}
else if( cubeSide == CubeSide.left )
{
texture_Right_left = new Texture2D( scaleX, scaleY, format, useMipmap );
}
else if( cubeSide == CubeSide.right )
{
texture_Right_right = new Texture2D( scaleX, scaleY, format, useMipmap );
}
else if( cubeSide == CubeSide.top )
{
texture_Right_top = new Texture2D( scaleX, scaleY, format, useMipmap );
}
else if( cubeSide == CubeSide.bottom )
{
texture_Right_bottom = new Texture2D( scaleX, scaleY, format, useMipmap );
}
}
} //END SetLoadedTextureScale
IEnumerator ToOpenCamera(CameraType type)
{
//获取摄像头权限
yield return(Application.RequestUserAuthorization(UserAuthorization.WebCam));
if (Application.HasUserAuthorization(UserAuthorization.WebCam))
{
//停止正在使用的摄像头
if (webCamTexture != null)
{
webCamTexture.Stop();
}
//判断时候有摄像头
if (WebCamTexture.devices.Length != 0)
{
//new一个摄像头并且设置分辨率和FPS，渲染到UI上
webCamTexture = new WebCamTexture(WebCamTexture.devices[(int)type].name,
(int)resolution.x, (int)resolution.y, fps);
rawImage.texture = webCamTexture;
webCamTexture.Play();
}
}
}
/// <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);
}
} //END SetLoadedTextureScale
//-----------------------------//
private void SetLoadedTextureWrapMode( CameraType cameraType, CubeSide cubeSide, TextureWrapMode wrapMode )
//-----------------------------//
{
if( cameraType == CameraType.Left )
{
if( cubeSide == CubeSide.front )
{
texture_Left_front.wrapMode = wrapMode;
}
else if( cubeSide == CubeSide.back )
{
texture_Left_back.wrapMode = wrapMode;
}
else if( cubeSide == CubeSide.left )
{
texture_Left_left.wrapMode = wrapMode;
}
else if( cubeSide == CubeSide.right )
{
texture_Left_right.wrapMode = wrapMode;
}
else if( cubeSide == CubeSide.top )
{
texture_Left_top.wrapMode = wrapMode;
}
else if( cubeSide == CubeSide.bottom )
{
texture_Left_bottom.wrapMode = wrapMode;
}
}
else if( cameraType == CameraType.Right )
{
if( cubeSide == CubeSide.front )
{
texture_Right_front.wrapMode = wrapMode;
}
else if( cubeSide == CubeSide.back )
{
texture_Right_back.wrapMode = wrapMode;
}
else if( cubeSide == CubeSide.left )
{
texture_Right_left.wrapMode = wrapMode;
}
else if( cubeSide == CubeSide.right )
{
texture_Right_right.wrapMode = wrapMode;
}
else if( cubeSide == CubeSide.top )
{
texture_Right_top.wrapMode = wrapMode;
}
else if( cubeSide == CubeSide.bottom )
{
texture_Right_bottom.wrapMode = wrapMode;
}
}
} //END SetLoadedTextureWrapMode
/// <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();
}
}
} //END GetLoadedBool
//-----------------------------//
private void SetLoadedBool( CameraType cameraType, CubeSide cubeSide, bool loaded )
//-----------------------------//
{
if( cameraType == CameraType.Left )
{
if( cubeSide == CubeSide.front )
{
bool_Left_front_loaded = loaded;
}
else if( cubeSide == CubeSide.back )
{
bool_Left_back_loaded = loaded;
}
else if( cubeSide == CubeSide.left )
{
bool_Left_left_loaded = loaded;
}
else if( cubeSide == CubeSide.right )
{
bool_Left_right_loaded = loaded;
}
else if( cubeSide == CubeSide.top )
{
bool_Left_top_loaded = loaded;
}
else if( cubeSide == CubeSide.bottom )
{
bool_Left_bottom_loaded = loaded;
}
}
else if( cameraType == CameraType.Right )
{
if( cubeSide == CubeSide.front )
{
bool_Right_front_loaded = loaded;
}
else if( cubeSide == CubeSide.back )
{
bool_Right_back_loaded = loaded;
}
else if( cubeSide == CubeSide.left )
{
bool_Right_left_loaded = loaded;
}
else if( cubeSide == CubeSide.right )
{
bool_Right_right_loaded = loaded;
}
else if( cubeSide == CubeSide.top )
{
bool_Right_top_loaded = loaded;
}
else if( cubeSide == CubeSide.bottom )
{
bool_Right_bottom_loaded = loaded;
}
}
} //END SetLoadedBool
private void changeProjectionYoolStripMenuItem_Click(object sender, EventArgs e)
{
var senderItem = sender as ToolStripMenuItem;
int.TryParse(senderItem.Tag.ToString(), out int cameraTypeInt);
CameraType type = (CameraType)cameraTypeInt;
foreach (var item in projectionToolStripMenuItem.DropDownItems)
{
var meunItem = item as ToolStripMenuItem;
if (meunItem == sender)
{
meunItem.Checked = true;
int.TryParse(meunItem.Tag.ToString(), out cameraTypeInt);
Scene.Instance.GetMainCamera().Type = (CameraType)cameraTypeInt;
}
if ((meunItem != null) && (meunItem != sender))
{
meunItem.Checked = false;
}
}
if (type == CameraType.Orthographic)
{
projectionButton.Tag = (int)CameraType.Orthographic;
projectionButton.Image = Properties.Resources.Orthographic;
Scene.Instance.GetMainCamera().Type = CameraType.Orthographic;
}
else
{
projectionButton.Tag = (int)CameraType.Perspective;
projectionButton.Image = Properties.Resources.Perspective;
Scene.Instance.GetMainCamera().Type = CameraType.Perspective;
}
}
private void projectionButton_Click(object sender, EventArgs e)
{
var button = sender as ToolStripButton;
int.TryParse(button.Tag.ToString(), out int cameraTypeInt);
CameraType type = (CameraType)cameraTypeInt;
if (type == CameraType.Perspective)
{
button.Tag = (int)CameraType.Orthographic;
button.Image = Properties.Resources.Orthographic;
Scene.Instance.GetMainCamera().Type = CameraType.Orthographic;
}
else
{
button.Tag = (int)CameraType.Perspective;
button.Image = Properties.Resources.Perspective;
Scene.Instance.GetMainCamera().Type = CameraType.Perspective;
}
foreach (var item in projectionToolStripMenuItem.DropDownItems)
{
var meunItem = item as ToolStripMenuItem;
int.TryParse(meunItem.Tag.ToString(), out cameraTypeInt);
if ((CameraType)cameraTypeInt != type)
{
meunItem.Checked = true;
}
else
{
meunItem.Checked = false;
}
}
}
/// <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();
}
public static void Update(Camera camera)
{
if (Camera.Type == CameraType.StaticCam)
{
camera.Reset();
}
else
{
if (Camera.Type == CameraType.RotationCam)
{
camera.Rotate_World_Y(0.005f);
int uView = GL.GetUniformLocation(ACWWindow.mShader.ShaderProgramID, "uView");
GL.UniformMatrix4(uView, true, ref ACWWindow.mView);
}
else if (Camera.Type == CameraType.FollowCam)
{
if (Sphere.DrawList.Count != 0)
{
ACWWindow.mView = Matrix4.CreateTranslation(0, 0, -10) * Matrix4.CreateTranslation(-Sphere.DrawList[0].mPosition);
int uView = GL.GetUniformLocation(ACWWindow.mShader.ShaderProgramID, "uView");
GL.UniformMatrix4(uView, true, ref ACWWindow.mView);
ACWWindow.mGroundModel = Matrix4.CreateTranslation(1, -0.5f, 0f);
}
}
else if (Camera.Type != CameraType.FreeCam)
{
Camera.Type = CameraType.StaticCam;
}
}
}
public Camera(CameraType type, CameraParameters parameters = null, string name = "") : base(name)
{
// Create/Save Name
counter++;
if (name == string.Empty)
{
Name = "Camera " + counter.ToString();
}
else
{
Name = name;
}
// Create/Save Parameters
if (parameters == null)
{
Parameters = new CameraParameters();
}
else
{
Parameters = parameters;
}
// Create View Matrix
LookAt(parameters.Position, parameters.Target, parameters.WorldUp);
// Set both orthographic and perspective cameras
SetPerspective(Parameters);
SetOrthographic(Parameters);
Type = type;
}
public void SetCameraType(CameraType type)
{
Type = type;
switch (type)
{
case CameraType.Behind:
case CameraType.Parallel:
Movable = false;
Orientable = false;
PositionCamera(type);
OrientToBoids();
break;
case CameraType.Tower:
Movable = false;
Orientable = false;
Position = TowerCameraPosition;
OrientToBoids();
break;
case CameraType.Free:
Movable = true;
Orientable = true;
var vertRads = Math.Asin(-Front.Y);
Pitch = Utils.Rad2Deg(vertRads);
Yaw = Utils.Rad2Deg(Math.Acos(-Front.Z / Math.Cos(vertRads)));
UpdateCameraVectors();
break;
}
}
///// <summary>
///// 默认目标为vec3(0, 0, -1)
///// </summary>
//public static readonly vec3 defaultTarget = new vec3(0, 0, -1);
///// <summary>
///// 默认位置为vec3(0, 0, 0)
///// </summary>
//public static readonly vec3 defaultPosition = new vec3(0, 0, 0);
///// <summary>
///// 默认上方为vec3(0, 1, 0)
///// </summary>
//public static readonly vec3 defaultUpVector = new vec3(0, 1, 0);
/// <summary>
/// Camera.
/// </summary>
/// <param name="position">position in world space</param>
/// <param name="target">target in world space.</param>
/// <param name="up">up in world space.</param>
/// <param name="cameraType">perspective or ortho?</param>
/// <param name="width">canvas' width.</param>
/// <param name="height">canvas' height.</param>
public Camera(vec3 position, vec3 target, vec3 up, CameraType cameraType, double width, double height)
{
this.Position = position;
this.Target = target;
this.UpVector = up;
IPerspectiveCamera perspectiveCamera = this;
perspectiveCamera.FieldOfView = 60.0f;
perspectiveCamera.AspectRatio = width / height;
perspectiveCamera.Near = 0.1;
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.CameraType = cameraType;
}
protected virtual void Start()
{
if (!EM_Settings.IsSubmoduleEnable(Submodule.Media))
{
curtain.SetActive(true);
return;
}
else
{
curtain.SetActive(false);
}
takePictureButton.onClick.AddListener(TakePicture);
recordVideoButton.onClick.AddListener(RecordVideo);
pickButton.onClick.AddListener(PickFromGallery);
saveImageButton.onClick.AddListener(SaveImage);
clearViewsButton.onClick.AddListener(ClearDisplayedViews);
randomTextureButton.onClick.AddListener(RandomDisplayImage);
clearTexutreButton.onClick.AddListener(ClearDisplayImage);
InitDropdownWithEnum(imageFormatDropdown, typeof(ImageFormat));
InitDropdownWithEnum(cameraTypeDropdown, typeof(CameraType));
cameraTypeDropdown.onValueChanged.AddListener(index => currentCameraType = (CameraType)index);
bool hasFrontCamera = Media.Camera.IsCameraAvailable(CameraType.Front);
bool hasRearCamera = Media.Camera.IsCameraAvailable(CameraType.Rear);
demoUtils.DisplayBool(frontCameraSupportedToggle, hasFrontCamera, hasFrontCamera ? "Front Camera Available" : "Front Camera Unavailable");
demoUtils.DisplayBool(backCameraSupportedToggle, hasRearCamera, hasRearCamera ? "Rear Camera Available" : "Rear Camera Unavailable");
}
/// <summary>
/// Enabled based on camera type.
/// </summary>
/// <param name="cameraType">Enable which camera.</param>
public void EnableCamera(CameraType cameraType)
{
switch (cameraType)
{
case CameraType.FIRST_PERSON:
{
m_firstPersonCamera.enabled = true;
m_thirdPersonCamera.enabled = false;
m_topDownCamera.enabled = false;
Camera.main.fieldOfView = m_firstPersonCamera.m_fieldOfViewSetting;
break;
}
case CameraType.THIRD_PERSON:
{
m_firstPersonCamera.enabled = false;
m_thirdPersonCamera.enabled = true;
m_topDownCamera.enabled = false;
Camera.main.fieldOfView = m_thirdPersonCamera.m_fieldOfViewSetting;
break;
}
case CameraType.TOP_DOWN:
{
m_firstPersonCamera.enabled = false;
m_thirdPersonCamera.enabled = false;
m_topDownCamera.enabled = true;
Camera.main.fieldOfView = m_topDownCamera.m_fieldOfViewSetting;
break;
}
}
m_currentCamera = cameraType;
}
public void Awake()
{
_aspectCamera = GetComponent <Camera>();
if (_aspectCamera.orthographic)
{
_ct = CameraType.Orthographic;
}
else
{
_ct = CameraType.Perspective;
}
_prevMode = _adjustMode;
//_prevVerticalSnapMode = _verticalSnapMode;
//_prevHorizontalSnapMode = _horizontalSnapMode;
_prevWidth = _mainAreaWidth;
_prevHeight = _mainAreaHeight;
_prevHSize = horizontalSize;
_prevVSize = verticalSize;
_prevHFOV = horizontalFOV;
_prevVFOV = verticalFOV;
_cameraPrevPixelWidth = _aspectCamera.pixelWidth;
_cameraPrevPixelHeight = _aspectCamera.pixelHeight;
}
public void ShowCamera(CameraType cameraType)
{
//Reset Camera Priorities
vCamMainMenu.Priority = 0;
vCamGamePlay.Priority = 0;
vCamLevelComplete.Priority = 0;
switch (cameraType)
{
case CameraType.MainMenu:
vCamMainMenu.Priority = 1;
break;
case CameraType.Gameplay:
vCamGamePlay.Priority = 1;
break;
case CameraType.LevelComplete:
vCamLevelComplete.Priority = 1;
break;
default:
throw new ArgumentOutOfRangeException(nameof(cameraType), cameraType, null);
}
}
public override bool TrySetupObjectUIControl(EditorSceneBase scene, ObjectUIControl objectUIControl)
{
if (!Selected)
{
return(false);
}
objectUIControl.AddObjectUIContainer(new CameraUI(this, scene), "General Settings");
if (mFields.Keys.Any(k => k.StartsWith("flag.")))
{
objectUIControl.AddObjectUIContainer(new CameraFlagsUI(this, scene), "Camera Flags");
}
// camera types "Cube", "Group", "Start", and "Other" load the chunk CameraParamChunkGame
// "Event" loads CameraParamChunkEvent
CameraType type = GetCameraType();
if (type == CameraType.Cube || type == CameraType.Group || type == CameraType.Start || type == CameraType.Other)
{
objectUIControl.AddObjectUIContainer(new CameraGameFlagsUI(this, scene), "Camera Game Flags");
}
if (type == CameraType.Event)
{
objectUIControl.AddObjectUIContainer(new CameraEventFlagsUI(this, scene), "Camera Event Flags");
}
return(true);
}
public void GetModelviewMatrix(CameraType type, out Matrix4 matrix)
{
this.GetModelviewMatrix(out matrix);
Console.WriteLine(matrix);
Console.WriteLine(left_modelview);
Console.WriteLine(right_modelview);
switch (type)
{
case CameraType.Default:
// Nothing to do
break;
case CameraType.Left:
Matrix4.Mult(ref matrix, ref left_modelview, out matrix);
break;
case CameraType.Right:
Matrix4.Mult(ref matrix, ref right_modelview, out matrix);
break;
default:
throw new NotSupportedException();
}
}
/// <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);
}
public void SetCamera(CameraType type)
{
foreach (GameObject camera in cameras)
{
camera.GetComponent <CameraController>().Show(type);
}
}
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 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 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 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();
}
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;
}
}
}
public ThermoCam(System.Windows.Forms.Form f, CameraType camType, DeviceType devType, InterfaceType interfaceType)
{
this._camType = camType;
this._devType = devType;
this._interfaceType = interfaceType;
//Crear nueva lista de zonas
this.SubZonas = new List<SubZona>();
((System.ComponentModel.ISupportInitialize)(camara)).BeginInit();
camara.Visible = false;
f.Controls.Add(camara);
camara.CameraEvent += camara_CameraEvent;
((System.ComponentModel.ISupportInitialize)(camara)).EndInit();
}
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
};
}
/// <summary>
/// Gets the photo camera of the <paramref name="cameraType"/> specified.
/// </summary>
/// <param name="cameraType">Photo camera type.</param>
/// <returns>Photo camera.</returns>
/// <exception cref="ArgumentException"><paramref name="cameraType"/> is not supported.</exception>
public async Task<PhotoCamera> GetCameraAsync(CameraType cameraType)
{
if ((await DeviceHelper.GetCameraDeviceInfoAsync(cameraType)) == null)
{
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "{0} camera is not supported.", cameraType), "cameraType");
}
lock (this.cameras)
{
if (!this.cameras.ContainsKey(cameraType))
{
this.cameras[cameraType] = new PhotoCamera(cameraType);
}
return this.cameras[cameraType];
}
}
public Camera()
{
viewMatrix = Matrix.Identity;
projectionMatrix = Matrix.Identity;
headOffset = new Vector3(0, 15, 17);
targetOffset = new Vector3(0, 5, 0);
cameraType = CameraType.ChaseCamera;
position = headOffset;
reference = 0;
turnAmount = Vector3.Zero;
cameraUpVector = Vector3.Up;
m_AngleX = 0;
m_AngleY = 0;
}
public static CameraController Factory( CameraType type, Game game )
{
CameraController cameraController = null;
switch ( type ) {
case CameraType.CAMERA_TYPE_FIRST_PERSON:
cameraController = new FirstPersonCameraController( game );
break;
case CameraType.CAMERA_TYPE_TOP_DOWN:
cameraController = new TopDownCameraController( game );
break;
case CameraType.CAMERA_TYPE_FREE:
default:
cameraController = new CameraController( game );
break;
}
return cameraController;
}
public void SetThirdPersonCamera(bool animated = false)
{
if (_animating || cameraType == CameraType.ThirdPerson)
return;
_cameraType = CameraType.ThirdPerson;
if (animated)
{
StartCoroutine(SetThirdPersonCameraAnimated());
}
else
{
SetFirstPersonComponentsEnabled(false);
SetThirdPersonComponentsEnabled(true);
}
}
/// <summary>
/// Gets the camera device information with the <paramref name="cameraType"/> specified.
/// </summary>
/// <param name="cameraType">Camera type.</param>
/// <returns>Device information, or <see langword="null"/>, if no suitable devices found.</returns>
/// <exception cref="ArgumentException"><paramref name="cameraType"/> is not supported.</exception>
public static async Task<DeviceInformation> GetCameraDeviceInfoAsync(CameraType cameraType)
{
Panel desiredPanel;
switch (cameraType)
{
case CameraType.Primary:
desiredPanel = Panel.Back;
break;
case CameraType.FrontFacing:
desiredPanel = Panel.Front;
break;
default:
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Camera type {0} is not supported.", cameraType), "cameraType");
}
// Make sure the device info cache is populated.
await DeviceHelper.EnumerateCameraDevicesAsync();
return DeviceHelper.CameraDeviceInfoCache.ContainsKey(desiredPanel) ? DeviceHelper.CameraDeviceInfoCache[desiredPanel] : null;
}
public void AddCamera(CameraType Type, string CameraName, Vector3 Position, float NearClip, float FarClip)
{
switch (Type) //<-- Switch with an enumeration found up top to add in additional cameras
{
case CameraType.Free:
{
FreeCamera Dummy = new FreeCamera();
FreeCamera.Initialize(Dummy, Position, NearClip, FarClip, mGraphics.Peek.AspectRatio());
_Cameras.Add(CameraName, Dummy);
}
break;
case CameraType.Fixed:
{
FixedCamera Dummy = new FixedCamera();
FixedCamera.Initialize(Dummy, Position, NearClip, FarClip, mGraphics.Peek.AspectRatio());
_Cameras.Add(CameraName, Dummy);
}
break;
}
}
/// <summary>
/// Enabled based on camera type.
/// </summary>
/// <param name="cameraType">Enable which camera.</param>
public void EnableCamera(CameraType cameraType)
{
switch (cameraType)
{
case CameraType.FIRST_PERSON:
{
transform.position = m_targetFollowingObject.transform.position;
transform.rotation = m_targetFollowingObject.transform.rotation;
break;
}
case CameraType.THIRD_PERSON:
{
startThirdPersonRotationX = 45.0f;
startThirdPersonRotationY = -45.0f;
startThirdPersonCameraCircleR = 0.0f;
curThirdPersonCameraCircleR = 7.0f;
curThirdPersonRotationX = startThirdPersonRotationX + (Mathf.PI * (0.0f / Screen.width));
curThirdPersonRotationY = startThirdPersonRotationY + (Mathf.PI * (0.0f / Screen.height));
Vector3 newPos = new Vector3(curThirdPersonCameraCircleR * Mathf.Sin(curThirdPersonRotationX),
curThirdPersonCameraCircleR * Mathf.Cos(curThirdPersonRotationY),
curThirdPersonCameraCircleR * Mathf.Cos(curThirdPersonRotationX));
m_curOffset = m_thirdPersonCamOffset = newPos;
transform.position = m_targetFollowingObject.transform.position + m_curOffset;
transform.LookAt(m_targetFollowingObject.transform.position);
break;
}
case CameraType.TOP_DOWN:
{
m_topDownCamOffset = new Vector3(0.0f, 7.0f, 0.0f);
break;
}
}
m_currentCamera = cameraType;
}
public Match(Game game, Team homeTeam, Team awayTeam, CameraType cameraType, Difficulty difficulty, Weather weather, int duration, bool player2Cpu)
: base(game)
{
CameraType = cameraType;
Difficulty = difficulty;
Weather = weather;
Duration = duration;
HomeTeam = homeTeam;
AwayTeam = awayTeam;
AwayTeam.IsHomeTeam = false;
Player1Index = 0;
Player2Index = 0;
Player2Cpu = player2Cpu;
Scenario = new Scenario2D(Game);
Scenario2DPainter = new Scenario2DPainter(Game.GraphicsDevice, Scenario);
timer = -1;
Pause = false;
DisplayRadar = true;
hold = true;
KickOff = true;
KickOffStart = true;
HomeTeamStart = true;
FreeKickStart = false;
TmpTeam = null;
Ball = new Ball(game, Weather);
Field = new Field(game);
Panel = new Panel(game);
//passing
MaxPassSpeed = 800;
MaxErrorAngle = 15;
PerfectPassFactor = 2.8f;
Rand = new Random();
Audience = new Song[3];
}
///// <summary>
///// 默认目标为vec3(0, 0, -1)
///// </summary>
//public static readonly vec3 defaultTarget = new vec3(0, 0, -1);
///// <summary>
///// 默认位置为vec3(0, 0, 0)
///// </summary>
//public static readonly vec3 defaultPosition = new vec3(0, 0, 0);
///// <summary>
///// 默认上方为vec3(0, 1, 0)
///// </summary>
//public static readonly vec3 defaultUpVector = new vec3(0, 1, 0);
/// <summary>
/// Camera.
/// </summary>
/// <param name="position">position in world space</param>
/// <param name="target">target in world space.</param>
/// <param name="up">up in world space.</param>
/// <param name="cameraType">perspective or ortho?</param>
/// <param name="width">canvas' width.</param>
/// <param name="height">canvas' height.</param>
public Camera(vec3 position, vec3 target, vec3 up, CameraType cameraType, double width, double height)
{
this.Position = position;
this.Target = target;
this.UpVector = up;
IPerspectiveCamera perspectiveCamera = this;
perspectiveCamera.FieldOfView = 60.0f;
perspectiveCamera.AspectRatio = width / height;
perspectiveCamera.Near = 0.1;
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.CameraType = cameraType;
}
