public void SetupCaptureProcess(CaptureHeadbox capture_notification_component,
                                 CaptureBuilder capture)
 {
     capture_timer_ = kTimerExpirationsPerCapture;
     bake_stage_    = BakeStage.kCapture;
     last_time_     = Time.realtimeSinceStartup;
     capture_notification_component_ = capture_notification_component;
     monitored_capture_ = capture;
 }
Esempio n. 2
0
 void StopCapture()
 {
     Debug.Log("Capture stop", this);
     if (capture_ != null)
     {
         capture_.EndCapture();
     }
     capture_ = null;
     Time.captureFramerate = 0;
 }
    public override void OnInspectorGUI()
    {
        serializedObject.Update();

        EditorGUILayout.PropertyField(output_folder_, new GUIContent(
                                          "Output Folder"));
        if (GUILayout.Button("Choose Output Folder"))
        {
            string path = EditorUtility.SaveFolderPanel(
                "Choose Capture Output Folder", output_folder_.stringValue, "");
            if (path.Length != 0)
            {
                output_folder_.stringValue = path;
            }
        }

        EditorGUILayout.PropertyField(size_, new GUIContent("Headbox Size"));
        EditorGUILayout.PropertyField(samples_, new GUIContent("Sample Count"));
        EditorGUILayout.PropertyField(center_resolution_, new GUIContent(
                                          "Center Capture Resolution"));
        EditorGUILayout.PropertyField(resolution_, new GUIContent(
                                          "Default Resolution"));
        EditorGUILayout.PropertyField(dynamic_range_, new GUIContent(
                                          "Dynamic Range"));

        EditorGUILayout.PropertyField(last_output_dir_, new GUIContent(
                                          "Last Output Folder"));

        if (capture_status_ != null)
        {
            GUI.enabled = false;
        }
        if (GUILayout.Button("Capture"))
        {
            Capture();
        }
        GUI.enabled = true;

        serializedObject.ApplyModifiedProperties();

        // Poll the bake status.
        if (bake_progress_window_ != null && bake_progress_window_.IsComplete())
        {
            bake_progress_window_.Close();
            bake_progress_window_ = null;
            capture_builder_      = null;
            capture_status_       = null;
        }
    }
    void StartCapture()
    {
        Debug.Log("Capture start - temporarily setting fixed framerate.", this);
        capture_ = new CaptureBuilder();

        string capture_output_folder = output_folder_;

        if (capture_output_folder.Length <= 0)
        {
            capture_output_folder = FileUtil.GetUniqueTempPathInProject();
        }
        Directory.CreateDirectory(capture_output_folder);
        capture_.BeginCapture(this, capture_output_folder, 1, new CaptureStatus());

        // See Time.CaptureFramerate example, e.g. here:
        // https://docs.unity3d.com/ScriptReference/Time-captureFramerate.html
        Time.captureFramerate = 60;
    }
    public void Update()
    {
        if (capture_status_ != null && capture_status_.TaskContinuing() && !UpdateAndCheckUiTimerReady())
        {
            return;
        }

        // Refresh the Editor GUI to finish the task.
        EditorUtility.SetDirty(capture_notification_component_);

        if (bake_stage_ == BakeStage.kCapture)
        {
            --capture_timer_;
            if (capture_timer_ == 0)
            {
                capture_timer_ = kTimerExpirationsPerCapture;

                monitored_capture_.RunCapture();

                if (monitored_capture_.IsCaptureComplete() &&
                    capture_status_.TaskContinuing())
                {
                    monitored_capture_.EndCapture();
                    monitored_capture_ = null;

                    bake_stage_ = BakeStage.kWaitForDoneButton;
                }
            }

            if (capture_status_ != null && !capture_status_.TaskContinuing())
            {
                bake_stage_ = BakeStage.kComplete;
                if (monitored_capture_ != null)
                {
                    monitored_capture_.EndCapture();
                    monitored_capture_ = null;
                }
            }
        }

        // Repaint with updated progress the GUI on each wall-clock time tick.
        Repaint();
    }
    public void Capture()
    {
        CaptureHeadbox headbox = (CaptureHeadbox)target;

        string capture_output_folder = headbox.output_folder_;

        if (capture_output_folder.Length <= 0)
        {
            capture_output_folder = FileUtil.GetUniqueTempPathInProject();
        }
        headbox.last_output_dir_ = capture_output_folder;
        Directory.CreateDirectory(capture_output_folder);

        capture_status_  = new EditorBakeStatus();
        capture_builder_ = new CaptureBuilder();

        // Kick off the interactive Editor bake window.
        bake_progress_window_ = (CaptureWindow)EditorWindow.GetWindow(typeof(CaptureWindow));
        bake_progress_window_.SetupStatus(capture_status_);

        capture_builder_.BeginCapture(headbox, capture_output_folder, 1, capture_status_);
        bake_progress_window_.SetupCaptureProcess(headbox, capture_builder_);
    }