private string level_name; // Custom level name // TODO: custom level names regex check for invalid chars void Awake () { camera_script = GameObject.FindGameObjectWithTag(Tags.main_cam).GetComponent<CameraSetup>(); level_builder_script = GameObject.FindGameObjectWithTag(Tags.game_manager).GetComponent<LevelBuilder>(); grid_script = GameObject.FindGameObjectWithTag(Tags.game_manager).GetComponent<Grid>(); levels_script = GameObject.FindGameObjectWithTag(Tags.game_manager).GetComponent<Levels>(); }
/// <summary> /// Saves the acquisition information in specific files. /// The data is stored based on the COLMAP file system. /// </summary> public static void SaveAcquisitionInformation(DataHandler dataHandler, CameraSetup cameraSetup) { COLMAPConnector.CreateDirectoryStructureForAcquisition(dataHandler.dataDirectory); COLMAPConnector.SaveCamerasInformation(cameraSetup.cameraModels, dataHandler.dataDirectory); COLMAPConnector.SaveImagesInformation(cameraSetup.cameraModels, dataHandler.dataDirectory); dataHandler.SaveAdditionalSetupInformation(cameraSetup); }
public void SetParamaters(CameraSetup value) { lastSetup = setup; setup = value; switch (value) { case CameraSetup.DEFAULT: parameters = defaultParameters; break; case CameraSetup.CANNON: parameters = cannonParameters; break; case CameraSetup.INVENTORY: parameters = inventoryParameters; break; default: break; } Cursor.lockState = parameters.lockCursor; Cursor.visible = parameters.showCursor; }
public override void Build(ref CameraSetup camSetup) { if (!Ball.IsValid()) { return; } var pos = Ball.Position + Vector3.Up * (24 + (Ball.CollisionBounds.Center.z * Ball.Scale)); var rot = Rotation.From(Angles); distanceTarget = distanceTarget.LerpTo(Distance, Time.Delta * 5.0f); var tr = Trace.Ray(pos, pos + rot.Backward * Distance) .Ignore(Ball) .WorldOnly() .Radius(8) .Run(); if (tr.Hit) { distanceTarget = Math.Min(distanceTarget, tr.Distance); } pos += rot.Backward * distanceTarget; // ball.RenderAlpha = Math.Clamp( (distanceTarget - 25.0f) / 50.0f, 0.0f, 1.0f ); camSetup.Position = pos; camSetup.Rotation = rot; camSetup.FieldOfView = 90; }
/// <summary> /// Resets the object's properties. /// </summary> public void Reset() { // Check if there is a rendering caller. renderingCaller = GetComponent <Rendering.Rendering>(); // Reset the key child components. _cameraSetup = CameraSetup.CreateOrResetCameraSetup(transform); _dataHandler = DataHandler.CreateOrResetDataHandler(transform); // Initialize the processing methods. _processingMethods = ProcessingMethod.CreateOrResetProcessingMethods(transform); for (int iter = 0; iter < _processingMethods.Length; iter++) { _processingMethods[iter].InitializeLinks(); } // Initialize the external tools. _externalHelpers = ExternalHelper.CreateOrResetExternalHelpers(transform); for (int iter = 0; iter < _externalHelpers.Length; iter++) { _externalHelpers[iter].InitializeLinks(); } // Get the method defining the container for the input images. _previewSourceImagesLoader = _processingMethods[0].PMColorTextureArray; // Reads the acquisition information from the source data directory. ReadAcquisitionInformation(); // Destroys all created method components. foreach (MonoBehaviour component in GetComponents <MonoBehaviour>()) { if (component is IMethodGUI) { DestroyImmediate(component); } } }
public override void PostCameraSetup(ref CameraSetup camSetup) { base.PostCameraSetup(ref camSetup); AddCameraEffects(ref camSetup); }
private void SetPipeline(CameraSetup setup) { var cfg = CreateConfig(setup); _pipeline = new Pipeline(); _pipeline.Start(cfg); }
public override void PostCameraSetup(ref CameraSetup setup) { base.PostCameraSetup(ref setup); if (lastCameraRot == Rotation.Identity) { lastCameraRot = setup.Rotation; } var angleDiff = Rotation.Difference(lastCameraRot, setup.Rotation); var angleDiffDegrees = angleDiff.Angle(); var allowance = 20.0f; if (angleDiffDegrees > allowance) { // We could have a function that clamps a rotation to within x degrees of another rotation? lastCameraRot = Rotation.Lerp(lastCameraRot, setup.Rotation, 1.0f - (allowance / angleDiffDegrees)); } else { //lastCameraRot = Rotation.Lerp( lastCameraRot, Camera.Rotation, Time.Delta * 0.2f * angleDiffDegrees ); } // uncomment for lazy cam //camera.Rotation = lastCameraRot; if (setup.Viewer != null) { AddCameraEffects(ref setup); } }
private Levels levels; // Reference to levels script void Awake() { camera_script = GameObject.FindGameObjectWithTag(Tags.main_cam).GetComponent<CameraSetup>(); levels = GetComponent<Levels>(); brick_array = new GameObject[20, 20]; max_types = 2; }
/// <summary> /// Associate available cameras with automation and setup class /// Connect camera to LightField /// </summary> /// <param name="experiment"></param> /// <returns></returns> private void AddAvailableCameras() { // Add available camera foreach (var camera in experiment_.AvailableDevices) { if (experiment_.AvailableDevices.Count > 0 && camera.Type == DeviceType.Camera) { experiment_ = new OpenLightField(this, visibleLightField: true).Experiment; // Connect camera to LightField experiment_.Add(camera); string cameraName = string.Format("Model: {0}, SN: {1}", camera.Model, camera.SerialNumber); // Assign background worker, identity, etc.. // through camera setup class CameraSetup cameraSetup = new CameraSetup(experiment_, this, cameraName); experiment_ = cameraSetup.Experiment; } } }
void Awake() { camera_script = GameObject.FindGameObjectWithTag(Tags.main_cam).GetComponent<CameraSetup>(); paddle = GameObject.FindGameObjectWithTag(Tags.paddle); ball_vector = new Vector3(x, y, 0f); rb = GetComponent<Rigidbody2D>(); bounce_sound = GetComponent<AudioSource>(); }
public override void PostCameraSetup(ref CameraSetup camSetup) { base.PostCameraSetup(ref camSetup); // camSetup.ViewModelFieldOfView = camSetup.FieldOfView + (FieldOfView - 80); AddCameraEffects(ref camSetup); }
private GameObject actual_paddle; // And paddle void Awake () { GM = GameManager.instance; camera_script = GameObject.FindGameObjectWithTag(Tags.main_cam).GetComponent<CameraSetup>(); grid_script = GameObject.FindGameObjectWithTag(Tags.game_manager).GetComponent<Grid>(); // Instantiate variables wall_array = new GameObject[5]; }
/// <summary> /// Resets the object's properties. /// </summary> void Reset() { // Reset the key child components. _cameraSetup = CameraSetup.CreateOrResetCameraSetup(transform); _dataHandler = DataHandler.CreateOrResetDataHandler(transform); // Reset other properties. scaleFactor = 0.01f; repositionAroundCenter = true; }
static ViewportWrapper CreateViewPort(GameObject gameObject, int x, int y, int width, int height, CameraSetup cameraSetup, bool shadowEffectEnabled) { if (gameObject is FinishLine) { return(new FinishLineViewport(x, y, width, height, gameObject)); } return(new GameObjectViewport(x, y, width, height, gameObject, cameraSetup, shadowEffectEnabled)); }
/// <summary> /// Reads images information from a COLMAP "images.txt" file, and saves it into the referenced array. /// Note that the array contains a camera element for each image. Array elements will be initialized here. /// </summary> /// <param name="cameraSetup"></param> The camera setup to which to output the list of parsed camera models. /// <param name="workspace"></param> The workspace from which to work. public static void ReadImagesInformation(CameraSetup cameraSetup, string workspace) { List <Vector3> positionList = new List <Vector3>(); List <Quaternion> rotationList = new List <Quaternion>(); List <string> fileNameList = new List <string>(); List <int> cameraIDList = new List <int>(); // Read COLMAP's images file. using (StreamReader reader = File.OpenText(GetImagesFile(workspace))) { bool isOdd = false; string line; // Read the file line-by-line to the end. while ((line = reader.ReadLine()) != null) { // Skip the lines from the header, that start with #. if (!line.StartsWith("#")) { // If the line is odd, skip it, and indicate that the next line will be even. if (isOdd) { isOdd = false; } // If the line is even, parse it, and indicate that the next line will be odd. else { string[] split = line.Split(' '); // COLMAP's images should have 10 parameters. if (split.Length > 9) { // Parse position and rotation, and convert them to Unity's coordinate system. Quaternion rotation = new Quaternion(GeneralToolkit.ParseFloat(split[2]), GeneralToolkit.ParseFloat(split[3]), GeneralToolkit.ParseFloat(split[4]), GeneralToolkit.ParseFloat(split[1])); Vector3 position = new Vector3(GeneralToolkit.ParseFloat(split[5]), GeneralToolkit.ParseFloat(split[6]), GeneralToolkit.ParseFloat(split[7])); ConvertCoordinatesCOLMAPToUnity(ref position, ref rotation); // Add all the parameters to the dedicated lists. positionList.Add(position); rotationList.Add(rotation); fileNameList.Add(split[9]); cameraIDList.Add(GeneralToolkit.ParseInt(split[8])); // Indicate that the next line will be odd. isOdd = true; } } } } reader.Close(); } // Use these lists to create and fill the output array of camera models. cameraSetup.cameraModels = new CameraModel[positionList.Count]; for (int iter = 0; iter < positionList.Count; iter++) { CameraModel cameraModel = cameraSetup.AddCameraModel(iter); cameraModel.SetCameraReferenceIndexAndImageName(cameraIDList[iter], fileNameList[iter]); cameraModel.transform.localPosition = positionList[iter]; cameraModel.transform.localRotation = rotationList[iter]; } }
public override void PostCameraSetup(ref CameraSetup camSetup) { base.PostCameraSetup(ref camSetup); if (Zoomed) { camSetup.FieldOfView = 20; } }
private Config CreateConfig(CameraSetup setup) { var width = setup.RGBWidth; var height = setup.RGBHeight; var fps = setup.RGBFPS; var cfg = new Config(); cfg.EnableStream(Intel.RealSense.Stream.Color, width, height, Format.Bgr8, fps); return(cfg); }
private void Start() { Cursor.SetCursor(cursor, new Vector2(16, 0), CursorMode.Auto); OnLifesUpdated?.Invoke(lifesLeft); cameraSetup = FindObjectOfType <CameraSetup>(); playersEagle = FindObjectOfType <PlayersEagle>(); playersEagle.OnEagleDead += EndGame; PlayerPool.Instance.PreWarm(lifesLeft); EnemyCounter.OnAllEnemiesDead += GoToNextLevel; }
public virtual void AddToManagersBottomUp() { CameraSetup.ResetCamera(SpriteManager.Camera); AssignCustomVariables(false); MenuWindowInstance.MoveToFrbLayer(HUDLayer, HUDLayerGum); ChatHistoryInstance.MoveToFrbLayer(HUDLayer, HUDLayerGum); OkMessageInstance.MoveToFrbLayer(HUDLayer, HUDLayerGum); ConfirmationWindowInstance.MoveToFrbLayer(HUDLayer, HUDLayerGum); FlatRedBall.Gui.GuiManager.SortZAndLayerBased(); }
public override void PostCameraSetup(ref CameraSetup camSetup) { camSetup.ZNear = 0.1f; base.PostCameraSetup(ref camSetup); if (IsFlashlightOn) { _viewFlashlight.Rotation = Input.Rotation; _viewFlashlight.Position = EyePosition + Input.Rotation.Forward * FLASHLIGHT_DISTANCE; } }
/// <summary> /// Reads camera information from a COLMAP "cameras.txt" file, and saves it into the referenced array. /// Note that the array contains a camera element for each image. Array elements should already contain the cameras' pose information. /// </summary> /// <param name="cameraSetup"></param> The camera setup containing the camera models, one for each image. /// <param name="workspace"></param> The workspace from which to work. public static void ReadCamerasInformation(CameraSetup cameraSetup, string workspace) { // Only continue if there is information to work with. if (cameraSetup.cameraModels == null) { return; } // Parse the set of COLMAP cameras from the file. List <CameraModel> cameraModelList = new List <CameraModel>(); string[] lines = File.ReadAllLines(GetCamerasFile(workspace)); foreach (string line in lines) { if (!line.StartsWith("#")) { CameraModel cameraModel = TryParseCameraModel(line); if (cameraModel == null) { Debug.LogWarning("One or more of the camera models could not be parsed. Camera setup cannot be computed."); cameraSetup.ResetCameraModels(); return; } else { cameraModelList.Add(cameraModel); } } } CameraModel[] camerasInFile = cameraModelList.ToArray(); // Update the camera models from this information. CameraModel[] cameraModels = cameraSetup.cameraModels; for (int i = 0; i < cameraModels.Length; i++) { CameraModel cameraModel = cameraModels[i]; // The camera models should already know the COLMAP camera they are related to. int desiredCameraIndex = cameraModel.cameraReferenceIndex; // Find the corresponding COLMAP camera, and provide the camera model with its parameters. foreach (CameraModel cameraInFile in camerasInFile) { if (cameraInFile.cameraReferenceIndex == desiredCameraIndex) { cameraModel.isOmnidirectional = cameraInFile.isOmnidirectional; cameraModel.pixelResolution = cameraInFile.pixelResolution; cameraModel.fieldOfView = cameraInFile.fieldOfView; } } } // Destroy the temporary camera models. for (int iter = 0; iter < camerasInFile.Length; iter++) { CameraModel.DestroyImmediate(camerasInFile[iter].gameObject); } }
private void OnChecked(object sender, EventArgs eventArgs) { PlayerDataManager.SetFullScreen(FullScreenCheck.IsChecked.Value); ResizeText.Visible = !FullScreenCheck.IsChecked.Value; CameraSetup.Data.AllowWidowResizing = !FullScreenCheck.IsChecked.Value; CameraSetup.Data.IsFullScreen = FullScreenCheck.IsChecked.Value; CameraSetup.Data.Scale = FullScreenCheck.IsChecked.Value ? 100f : 50f; CameraSetup.ResetWindow(); CameraSetup.ResetCamera(); }
public void StartStreaming(Dispatcher dispatcher, CancellationTokenSource tokenSource, CameraSetup setup, Action <VideoFrame> updateColor) { if (dispatcher.Thread != Thread.CurrentThread) { throw new InvalidOperationException( "Call this constructor from UI thread please, because it creates ImageSource object for UI"); } _dispatcher = dispatcher; _tokenSource = tokenSource; _setup = setup; _state = State.Idle; SetPipeline(setup); Task.Factory.StartNew(() => BackgroundLoop(updateColor), tokenSource.Token); }
private void AddCameraEffects(ref CameraSetup camSetup) { Rotation = Local.Pawn.EyeRotation; float speed = Owner.Velocity.Length.LerpInverse(0, 320); Vector3 left = camSetup.Rotation.Left; Vector3 up = camSetup.Rotation.Up; if (Owner.GroundEntity != null) { _walkBob += Time.Delta * 25.0f * speed; } Position += up * MathF.Sin(_walkBob) * speed * -1; Position += left * MathF.Sin(_walkBob * 0.6f) * speed * -0.5f; }
public override void PostCameraSetup(ref CameraSetup camSetup) { base.PostCameraSetup(ref camSetup); if (!Local.Pawn.IsValid()) { return; } if (!activated) { lastPitch = camSetup.Rotation.Pitch(); lastYaw = camSetup.Rotation.Yaw(); activated = true; } Position = camSetup.Position; Rotation = camSetup.Rotation; camSetup.ViewModel.FieldOfView = FieldOfView; var newPitch = Rotation.Pitch(); var newYaw = Rotation.Yaw(); var pitchDelta = Angles.NormalizeAngle(newPitch - lastPitch); var yawDelta = Angles.NormalizeAngle(lastYaw - newYaw); var playerVelocity = Local.Pawn.Velocity; var verticalDelta = playerVelocity.z * Time.Delta; var viewDown = Rotation.FromPitch(newPitch).Up * -1.0f; verticalDelta *= (1.0f - System.MathF.Abs(viewDown.Cross(Vector3.Down).y)); pitchDelta -= verticalDelta * 1; var offset = CalcSwingOffset(pitchDelta, yawDelta); offset += CalcBobbingOffset(playerVelocity); Position += Rotation * offset; lastPitch = newPitch; lastYaw = newYaw; }
/// <summary> /// Enables the user to select the source camera index. /// </summary> protected void SubsectionSourceCameraIndex() { CameraSetup cameraSetup = _targetProcessing.cameraSetup; int sliderMaxInt = _targetProcessing.sourcePerViewGeometryCount; int newPreviewIndex = sliderMaxInt; if (sliderMaxInt > 0) { string label = "Source index:"; string tooltip = "The index, in the setup, of the source depth map to use as input for per-view mesh creation."; newPreviewIndex = EditorGUILayout.IntSlider(new GUIContent(label, tooltip), cameraSetup.previewIndex, 0, sliderMaxInt); } if (newPreviewIndex != cameraSetup.previewIndex) { cameraSetup.previewIndex = newPreviewIndex; cameraSetup.OnPreviewIndexChange(); SceneView.RepaintAll(); } }
private void AddCameraEffects(ref CameraSetup camSetup) { Rotation = Local.Pawn.EyeRot; // // Bob up and down based on our walk movement // var speed = Owner.Velocity.Length.LerpInverse(0, 320); var left = camSetup.Rotation.Left; var up = camSetup.Rotation.Up; if (Owner.GroundEntity != null) { walkBob += Time.Delta * 25.0f * speed; } Position += up * MathF.Sin(walkBob) * speed * -1; Position += left * MathF.Sin(walkBob * 0.6f) * speed * -0.5f; }
public void ConfigureCaptureToFile(string path, CameraSetup setup) { Connect(); lock (_lock) { if (_isCapturing) { CppAssembly.StopCaptureImageToFile(_cameraReaderPointer); } CppAssembly.StartCaptureImageToFile(_cameraReaderPointer, path, (uint)setup.RGBWidth, (uint)setup.RGBHeight, (uint)setup.RGBFPS, out var invokeResult); _isCapturing = true; _startTime = DateTime.Now; if (invokeResult != 0) { throw new InvalidOperationException($"StartRecording Failed #{invokeResult}."); } } }
private void AddCameraEffects(ref CameraSetup setup) { var speed = Velocity.Length.LerpInverse(0, 320); var forwardspeed = Velocity.Normal.Dot(setup.Rotation.Forward); var left = setup.Rotation.Left; var up = setup.Rotation.Up; if (GroundEntity != null) { walkBob += Time.Delta * 10.0f * speed; } setup.Position += up * MathF.Sin(walkBob) * speed * 2; setup.Position += left * MathF.Sin(walkBob * 0.6f) * speed * 1; // Camera lean lean = lean.LerpTo(Velocity.Dot(setup.Rotation.Right) * 0.01f, Time.Delta * 15.0f); var controller = Controller as WalkController; var wallRun = controller.WallRun; var wallRunLean = wallRun.GetWallJumpDirection(); if (wallRun.IsWallRunning) { Log.Info("wall run lean: " + wallRunLean.ToString()); Log.Info("dot: " + wallRunLean.Dot(setup.Rotation.Right) * 0.01f); lean = lean.LerpTo((wallRunLean.Dot(setup.Rotation.Right) * 0.01f) * 20f, Time.Delta * 10.0f); } var appliedLean = lean; appliedLean += MathF.Sin(walkBob) * speed * 0.2f; setup.Rotation *= Rotation.From(0, 0, appliedLean); speed = (speed - 0.7f).Clamp(0, 1) * 3.0f; fov = fov.LerpTo(speed * 5 * MathF.Abs(forwardspeed), Time.Delta * 2.0f); setup.FieldOfView += fov; }
/// <summary> /// Resets the object's properties. /// </summary> void Reset() { // Reset the key child components. _cameraSetup = CameraSetup.CreateOrResetCameraSetup(transform); _dataHandler = DataHandler.CreateOrResetDataHandler(transform); _previewCameraManager = PreviewCameraManager.CreateOrResetPreviewCameraManager(transform); #if UNITY_EDITOR // Reset parameters to their default values. _cameraPrefab = null; _cameraCount = new Vector2Int(4, 4); _acquireDepthData = false; _copyGlobalMesh = false; _setupType = SetupType.Grid; _setupDirection = SetupDirection.Outwards; _lockSetup = false; // Update the acquisition camera poses to reflect the updated setup. ComputeAcquisitionCameraPoses(); // Create a preview camera from the prefab. CreatePreviewCameraFromPrefab(); #endif //UNITY_EDITOR }
/// <summary> /// Reads the acquisition information to store camera parameters and poses. /// </summary> public void ReadAcquisitionInformation() { // Reset the setup's camera models. cameraSetup.ResetCameraModels(); // Check the data directory for source data. dataHandler.CheckStatusOfSourceData(out sourceColorCount, out sourcePerViewGeometryCount, out sourceGlobalGeometryCount, out sourceDataInfo); // Check that the source data directory is configured based on the COLMAP file structure. if (COLMAPConnector.DirectoryIsValidForReading(dataHandler.dataDirectory)) { // Read the pose data and camera parameters, and store it into the initial camera models. COLMAPConnector.ReadImagesInformation(cameraSetup, dataHandler.dataDirectory); COLMAPConnector.ReadCamerasInformation(cameraSetup, dataHandler.dataDirectory); // Only continue if camera models were successfully parsed. if (cameraSetup.cameraModels != null && cameraSetup.cameraModels.Length > 0) { #if UNITY_EDITOR // If needed, provide default parameters for the additional source data information. if (!File.Exists(dataHandler.additionalInfoFile)) { dataHandler.SaveCOLIBRIVRAdditionalInformation(cameraSetup); } #endif //UNITY_EDITOR // Read the additional information, and store it in the camera setup. if (File.Exists(dataHandler.additionalInfoFile)) { dataHandler.ReadCOLIBRIVRAdditionalInformation(cameraSetup); } #if UNITY_EDITOR // Update the gizmo size. cameraSetup.gizmoSize = CameraSetup.ComputeGizmoSize(cameraSetup.cameraModels); cameraSetup.UpdateGizmosSize(); #endif //UNITY_EDITOR } } // Check whether data has already been processed or bundled. dataHandler.CheckStatusOfDataProcessingAndBundling(out isDataReadyForBundling, out isDataBundled, out processedDataInfo); }
private void AddCameraEffects(ref CameraSetup setup) { var speed = Velocity.Length.LerpInverse(0, 320); var forwardspeed = Velocity.Normal.Dot(setup.Rotation.Forward); var left = setup.Rotation.Left; var up = setup.Rotation.Up; if (GroundEntity != null) { walkBob += Time.Delta * 25.0f * speed; } setup.Position += up * MathF.Sin(walkBob) * speed * 2; setup.Position += left * MathF.Sin(walkBob * 0.6f) * speed * 1; // Camera lean lean = lean.LerpTo(Velocity.Dot(setup.Rotation.Right) * 0.015f, Time.Delta * 15.0f); var appliedLean = lean; appliedLean += MathF.Sin(walkBob) * speed * 0.2f; setup.Rotation *= Rotation.From(0, 0, appliedLean); speed = (speed - 0.7f).Clamp(0, 1) * 3.0f; fov = fov.LerpTo(speed * 20 * MathF.Abs(forwardspeed), Time.Delta * 2.0f); setup.FieldOfView += fov; // var tx = new Sandbox.UI.PanelTransform(); // tx.AddRotation( 0, 0, lean * -0.1f ); // Hud.CurrentPanel.Style.Transform = tx; // Hud.CurrentPanel.Style.Dirty(); }
public virtual void AddToManagersBottomUp() { CameraSetup.ResetCamera(SpriteManager.Camera); AssignCustomVariables(false); }
void Awake() { camera_script = GameObject.FindGameObjectWithTag(Tags.main_cam).GetComponent<CameraSetup>(); }