private static bool CameraControl_ReflectOption(Studio.CameraControl __instance, ref float ___rateAddSpeed, ref Camera ___m_SubCamera)
            {
                if (IsStudio)
                {
                    return(true);
                }

                ___rateAddSpeed      = Studio.Studio.optionSystem.cameraSpeed;
                __instance.xRotSpeed = Studio.Studio.optionSystem.cameraSpeedX;
                __instance.yRotSpeed = Studio.Studio.optionSystem.cameraSpeedY;
                List <string> list = new List <string>();

                if (Singleton <Studio.Studio> .Instance.workInfo.visibleAxis)
                {
                    if (Studio.Studio.optionSystem.selectedState == 0)
                    {
                        list.Add("Studio/Col");
                    }
                    list.Add("Studio/Select");
                }
                list.Add("Studio/Route");

                //Added null check
                if (___m_SubCamera != null)
                {
                    ___m_SubCamera.cullingMask = LayerMask.GetMask(list.ToArray());
                }
                return(false);
            }
Example #2
0
        private IEnumerator AutosaveStudio()
        {
            while (true)
            {
                yield return(new WaitForSeconds(AutosaveInterval.Value * 60));

                //Studio not loaded yet
                if (!Studio.Studio.IsInstance())
                {
                    continue;
                }

                if (AutosaveFileLimit.Value != 0 && AutosaveEnabled.Value)
                {
                    //Display a counter before saving so that the user has a chance to stop moving the camera around
                    if (AutosaveCountdown.Value > 0)
                    {
                        for (int countdown = AutosaveCountdown.Value; countdown > 0; countdown--)
                        {
                            SetText($"Autosaving in {countdown}");
                            yield return(new WaitForSeconds(1));
                        }
                    }

                    SetText("Saving...");
                    yield return(new WaitForSeconds(1));

                    //Don't save if the user is in the middle of clicking and dragging
                    while (Input.GetMouseButton(0) || Input.GetMouseButton(1) || Input.GetMouseButton(2))
                    {
                        yield return(new WaitForSeconds(1));
                    }

                    //Needed so the thumbnail is correct
                    yield return(new WaitForEndOfFrame());

                    Autosaving = true;

                    //Game runs similar code
                    foreach (KeyValuePair <int, ObjectCtrlInfo> item in Studio.Studio.Instance.dicObjectCtrl)
                    {
                        item.Value.OnSavePreprocessing();
                    }
                    Studio.CameraControl m_CameraCtrl = (Studio.CameraControl)Traverse.Create(Studio.Studio.Instance).Field("m_CameraCtrl").GetValue();
                    Studio.Studio.Instance.sceneInfo.cameraSaveData = m_CameraCtrl.Export();
                    DateTime now  = DateTime.Now;
                    string   str  = $"autosave_{now.Year}_{now.Month:00}{now.Day:00}_{now.Hour:00}{now.Minute:00}_{now.Second:00}_{now.Millisecond:000}.png";
                    string   path = $"{UserData.Create(AutosavePathStudio)}{str}";
                    Studio.Studio.Instance.sceneInfo.Save(path);

                    DeleteAutosaves(AutosavePathStudio);

                    SetText("Saved!");
                    Autosaving = false;
                    yield return(new WaitForSeconds(2));

                    SetText("");
                }
            }
        }
        private bool CameraControllerInit()
        {
            bool result = false;

            try
            {
                Console.WriteLine("Install Camera Control");
                Studio.CameraControl cameraControl = UnityEngine.Object.FindObjectOfType <Studio.CameraControl>();
                if (cameraControl == null)
                {
                    Console.WriteLine("camera contoller not found");
                    return(false);
                }
                this.cameraControllerFunc = delegate(bool enable)
                {
                    try
                    {
                        cameraControl.enabled = enable;
                    }
                    catch
                    {
                    }
                };
                result = true;
            }
            catch
            {
                Console.WriteLine("exception : camera contoller setting failed");
            }
            return(result);
        }
 public void hsneo_dump_camera2(StreamWriter file)
 {
     Studio.Studio                   studio = Studio.Studio.Instance;
     Studio.CameraControl            c      = studio.cameraCtrl;
     Studio.CameraControl.CameraData cdata  = cameraData;
     file.WriteLine(String.Format("game.move_camera(pos=%s, distance=%s, rotate=%s)", cdata.pos.ToString(), cdata.distance.ToString(), cdata.rotate.ToString()));
     file.WriteLine(String.Format("# for VN Scene Script %s", this.camera_calcstr_for_vnscene()));
     file.WriteLine(String.Format("# other one: 'cam': {{ 'goto_pos': (({0:F3}, {1:F3}, {2:F3}), ({3:F3}, {4:F3}, {5:F3}), ({6:F3}, {7:F3}, {8:F3})) }}, ", cdata.pos.x, cdata.pos.y, cdata.pos.z, cdata.distance.x, cdata.distance.y, cdata.distance.z, cdata.rotate.x, cdata.rotate.y, cdata.rotate.z));
 }
Example #5
0
        internal void FarClipSetter(float value)
        {
            Studio.CameraControl cameraCtrl = Studio.Studio.Instance.cameraCtrl;
            var field        = Traverse.Create(cameraCtrl).Field("lensSettings");
            var lensSettings = field.GetValue <LensSettings>();

            lensSettings.FarClipPlane = value;
            field.SetValue(lensSettings);
            cameraCtrl.fieldOfView = cameraCtrl.fieldOfView;
        }
Example #6
0
        private static bool CameraControl_LateUpdate_Patch(Studio.CameraControl __instance)
        {
            if (!toggle)
            {
                return(true);
            }

            Traverse.Create(__instance).Method("CameraUpdate").GetValue();

            return(false);
        }
        private static void StartPOV()
        {
            var ctrlInfo = Studio.Studio.GetCtrlInfo(Singleton <Studio.Studio> .Instance.treeNodeCtrl.selectNode);

            if (!(ctrlInfo is OCIChar ocichar))
            {
                return;
            }

            var temp = GameObject.Find("StudioScene/Camera/CameraSet/CameraController");

            if (temp == null)
            {
                return;
            }

            cc = temp.GetComponent <Studio.CameraControl>();
            if (cc == null)
            {
                return;
            }

            chara = ocichar.charInfo;

            eyes = chara.eyeLookCtrl.eyeLookScript.eyeObjs;
            if (eyes == null)
            {
                return;
            }

            head = chara.objHeadBone;
            if (head == null)
            {
                return;
            }

            if (hideHead.Value)
            {
                head.SetActive(false);
            }

            var data = cc.Export();

            backupData = data;
            backupFov  = cc.fieldOfView;

            cc.Import(new Studio.CameraControl.CameraData(data)
            {
                distance = Vector3.zero
            });
            viewRotation = Vector3.zero;

            toggle = true;
        }
        override public void move_camera_direct(CamData cam)
        {
            Studio.CameraControl.CameraData cdata = cameraData;
            Studio.CameraControl            c     = studio.cameraCtrl;

            cdata.pos = cam.position;

            cdata.distance = cam.distance;

            cdata.rotate = cam.rotation;

            cdata.parse = cam.fov;
        }
Example #9
0
        private void Update()
        {
            if (togglePOV.Value.IsDown())
            {
                if (studio == null || cc == null)
                {
                    studio = Singleton <Studio.Studio> .Instance;
                    if (studio == null)
                    {
                        return;
                    }

                    cc = studio.cameraCtrl;
                    if (cc == null)
                    {
                        return;
                    }
                }

                if (!toggle)
                {
                    StartPOV();
                }
                else
                {
                    StopPOV();
                }
            }

            if (!toggle)
            {
                return;
            }

            if (chara == null)
            {
                StopPOV();
                return;
            }

            if (Input.GetKey(KeyCode.Mouse0))
            {
                var x = Input.GetAxis("Mouse X") * sensitivity.Value;
                var y = -Input.GetAxis("Mouse Y") * sensitivity.Value;

                viewRotation += new Vector3(y, x, 0f);
            }

            StartCoroutine(ApplyPOV());
        }
Example #10
0
 internal static void CameraControl_InputKeyProc_Postfix(Studio.CameraControl __instance, ref bool __result)
 {
     try
     {
         if (!Enabled.Value || __result)
         {
             return;
         }
         var newResult = __result;
         GetController().SafeProc(controller => newResult = controller.InputKeyProcHandler(__instance));
         __result = newResult;
     }
     catch (Exception err)
     {
         Logger.LogException(err, __instance, nameof(CameraControl_InputKeyProc_Postfix));
     }
 }
Example #11
0
        public bool InputKeyProcHandler(Studio.CameraControl instance)
        {
            // handle adding of extra camera (if needed) inside of key handling to avoid
            // issues with changing things out from under other plugins
            if (InitialCameraSavePending)
            {
                InitialCameraSavePending = false;
                StartCoroutine(ExecuteInitialCameraSave());
                return(false);
            }

            if (!StudioSceneInitialCamera.SelectInitialCameraShortcut.Value.IsDown())
            {
                return(false);
            }
            instance.SelectInitialCamera();
            return(true);
        }
            private static bool Studio_LoadScene(Studio.Studio __instance, string _path, ref bool __result, ref BackgroundCtrl ___m_BackgroundCtrl, ref Studio.CameraControl ___m_CameraCtrl)
            {
                if (IsStudio)
                {
                    return(true);
                }

                if (!File.Exists(_path))
                {
                    __result = false;
                    return(false);
                }
                __instance.InitScene(false);
                var sceneInfo = new SceneInfo();

                Traverse.Create(__instance).Property("sceneInfo").SetValue(sceneInfo);
                if (!sceneInfo.Load(_path))
                {
                    __result = false;
                    return(false);
                }
                LoadingScene = true;
                AddObjectAssist.LoadChild(sceneInfo.dicObject);
                ChangeAmount source = sceneInfo.caMap.Clone();

                __instance.AddMap(sceneInfo.map, false, false);
                sceneInfo.caMap.Copy(source);
                Singleton <MapCtrl> .Instance.Reflect();

                __instance.bgmCtrl.Play(__instance.bgmCtrl.no);
                __instance.envCtrl.Play(__instance.envCtrl.no);
                __instance.outsideSoundCtrl.Play(__instance.outsideSoundCtrl.fileName);
                //Add the component if it doesn't exist
                if (___m_BackgroundCtrl == null)
                {
                    ___m_BackgroundCtrl = Camera.main.gameObject.AddComponent <BackgroundCtrl>();
                }
                __instance.treeNodeCtrl.RefreshHierachy();
                if (sceneInfo.cameraSaveData != null)
                {
                    ___m_CameraCtrl.Import(sceneInfo.cameraSaveData);
                }
                __instance.cameraLightCtrl.Reflect();
                sceneInfo.dataVersion = sceneInfo.version;
                LoadingScene          = false;

                __result = true;
                return(false);
            }
Example #13
0
 internal static Studio.CameraControl GetCameraControl()
 {
     Studio.CameraControl cameraControl = null;
     Studio.Studio.Instance.SafeProc(instance => cameraControl = instance.cameraCtrl);
     return(cameraControl);
 }
Example #14
0
        // 画面再描画イベントみたいなもの。
        // たまに呼び出される。
        public void OnUpdate()
        {
            // キー状態の確認。
            // キーイベントみたいなものにハンドラを登録する訳ではないので、
            // なんかしたい人はとにかくOnUpdateで処理を書く。
            if (Input.GetKeyDown(KeyCode.F6))
            {
                Boolean isShift = Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift);
                if (isShift)
                {
                    // CameraControlクラスはIllusionさん作成のクラス。
                    // カメラの制御に関する各種制御を持っているのでこれを利用してカメラの制御をする。
                    // unityの世界のメソッドだけで処理しようとするとうまくいかない事があるのでがんばれ!
                    // CameraやVectory3dはunityのものです。
                    // illusionのものとunityのものがごっちゃごちゃになっています。
                    // Camera.mainはメインカメラです。これはUnityの機能で提供されています。
                    Studio.CameraControl component2 = Camera.main.GetComponent <Studio.CameraControl>();
                    component2.cameraAngle += new Vector3(0, 0, 270);
                }
                else
                {
                    Studio.CameraControl component2 = Camera.main.GetComponent <Studio.CameraControl>();
                    component2.cameraAngle += new Vector3(0, 0, 90);
                }
            }

            if (Input.GetKeyDown(KeyCode.F7))
            {
                Boolean isShift = Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift);
                Studio.CameraControl component = Camera.main.GetComponent <Studio.CameraControl>();
                if (isShift)
                {
                    component.SetCamera(new Vector3(0, getHeight(), 0), Vector3.zero, Quaternion.identity, Vector3.zero);

                    Studio.CameraControl component2 = Camera.main.GetComponent <Studio.CameraControl>();
                    component2.SetCamera(new Vector3(0, getHeight(), 0), new Vector3(0, 0, 0), Quaternion.identity, new Vector3(0, 0, (-1) * getDistance()));
                    component2.transform.Rotate(new Vector3(0, 0, 0));
                    component2.targetPos = new Vector3(0, getHeight(), 0);
                }
                else
                {
                    component.SetCamera(new Vector3(0, getHeight(), 0), Vector3.zero, Quaternion.identity, Vector3.zero);

                    Studio.CameraControl component2 = Camera.main.GetComponent <Studio.CameraControl>();
                    component2.SetCamera(new Vector3(0, getHeight(), 0), new Vector3(0, 180, 0), Quaternion.identity, new Vector3(0, 0, (-1) * getDistance()));
                    component2.transform.Rotate(new Vector3(0, 180, 0));
                    component2.targetPos = new Vector3(0, getHeight(), 0);
                }
            }
            if (Input.GetKeyDown(KeyCode.F8))
            {
                Boolean isShift = Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift);
                try
                {
                    Studio.CameraControl component = Camera.main.GetComponent <Studio.CameraControl>();
                    if (isShift)
                    {
                        component.SetCamera(new Vector3(0, getHeight(), 0), Vector3.zero, Quaternion.identity, Vector3.zero);

                        Studio.CameraControl component2 = Camera.main.GetComponent <Studio.CameraControl>();
                        component2.SetCamera(new Vector3(0, getHeight(), 0), new Vector3(0, 90, 0), Quaternion.identity, new Vector3(0, 0, (-1) * getDistance()));
                        component2.transform.Rotate(new Vector3(0, 90, 0));
                        component2.targetPos = new Vector3(0, getHeight(), 0);
                    }
                    else
                    {
                        component.SetCamera(new Vector3(0, getHeight(), 0), Vector3.zero, Quaternion.identity, Vector3.zero);

                        Studio.CameraControl component2 = Camera.main.GetComponent <Studio.CameraControl>();
                        component2.SetCamera(new Vector3(0, getHeight(), 0), new Vector3(0, 270, 0), Quaternion.identity, new Vector3(0, 0, (-1) * getDistance()));
                        component2.transform.Rotate(new Vector3(0, 270, 0));
                        component2.targetPos = new Vector3(0, getHeight(), 0);
                    }
                }
                catch (Exception e)
                {
                }
            }
        }