Exemple #1
0
        private void CameraRigControllerOnStart(On.RoR2.CameraRigController.orig_Start orig, CameraRigController self)
        {
            orig(self);
            var camera = self.sceneCam;

            if (camera != null)
            {
                if (_darknessEffect != null)
                {
                    Object.Destroy(_darknessEffect);
                    _darknessEffect = null;
                }

                //Only create the darkness on actual stages
                //This should help alleviate an issue that some players encounter with the shader causing problems on bazaar
                if (SceneInfo.instance?.countsAsStage == true)
                {
                    _darknessEffect         = camera.gameObject.AddComponent <DarknessEffect>();
                    _darknessEffect.enabled = false;
                    if (camera.depthTextureMode == DepthTextureMode.None)
                    {
                        camera.depthTextureMode = DepthTextureMode.Depth;
                        Debug.Log("Camera did not have depth texture enabled; enabling for use with darkness");
                    }
                }
            }
        }
Exemple #2
0
        private static void InitHandsAndHUDs(On.RoR2.CameraRigController.orig_Start orig, RoR2.CameraRigController self)
        {
            orig(self);

            if (!HandsReady)
            {
                SetupHands();
            }

            dominantHand.smallHud.Init(self);
            nonDominantHand.smallHud.Init(self);

            foreach (HUDQueueEntry queueEntry in wristHudQueue)
            {
                GetHandBySide(queueEntry.left).smallHud.AddHUDCluster(queueEntry.transform);
            }

            wristHudQueue.Clear();

            dominantHand.watchHud.Init(self);
            nonDominantHand.watchHud.Init(self);

            foreach (HUDQueueEntry queueEntry in watchHudQueue)
            {
                GetHandBySide(queueEntry.left).watchHud.AddHUDCluster(queueEntry.transform);
            }

            watchHudQueue.Clear();
        }
Exemple #3
0
        private static void InitCamera(On.RoR2.CameraRigController.orig_Start orig, CameraRigController self)
        {
            orig(self);

            if (self.sceneCam.cullingMask == (self.sceneCam.cullingMask | (1 << LayerIndex.triggerZone.intVal)))
            {
                self.sceneCam.cullingMask &= ~(1 << LayerIndex.triggerZone.intVal);
            }

            if (self.sceneCam.cullingMask == (self.sceneCam.cullingMask | (1 << LayerIndex.noDraw.intVal)))
            {
                self.sceneCam.cullingMask &= ~(1 << LayerIndex.noDraw.intVal);
            }

            if (self.gameObject.scene.name == "intro" && self.sceneCam.cullingMask == (self.sceneCam.cullingMask | (1 << LayerIndex.ui.intVal)))
            {
                self.sceneCam.cullingMask &= ~(1 << LayerIndex.ui.intVal);
            }

            if (Run.instance && ModConfig.UseConfortVignette.Value)
            {
                self.uiCam.gameObject.AddComponent <ConfortVignette>();
            }

            GameObject cameraOffsetObject = new GameObject("Camera Offset");

            cameraOffset = cameraOffsetObject.transform;
            cameraOffset.transform.SetParent(self.transform);
            cameraOffset.transform.localPosition = Vector3.zero;
            cameraOffset.transform.localRotation = Quaternion.identity;
            cameraOffset.transform.localScale    = Vector3.one;

            self.sceneCam.transform.SetParent(cameraOffset.transform);

            if (ModConfig.InitialRoomscaleValue && !Run.instance)
            {
                self.currentCameraState = self.desiredCameraState;
            }

            if (!ModConfig.InitialOculusModeValue && ModConfig.InitialRoomscaleValue)
            {
                if (liv)
                {
                    GameObject.Destroy(liv);
                }

                liv                   = self.gameObject.AddComponent <LIV.SDK.Unity.LIV>();
                liv.stage             = self.transform;
                liv.stageTransform    = cameraOffset.transform;
                liv.HMDCamera         = self.sceneCam;
                liv.excludeBehaviours = new string[]
                {
                    "AkAudioListener",
                    "Rigidbody",
                    "AkGameObj",
                    "CameraResolutionScaler",
                    "TranslucentImageSource"
                };
                liv.spectatorLayerMask = self.sceneCam.cullingMask;

                liv.enabled = true;
            }

            if (self.hud)
            {
                UIFixes.AdjustHUD(self.hud);
            }

            RoR2Application.instance.mainCanvas.worldCamera = self.uiCam;

            if (FocusChecker.instance)
            {
                FocusChecker.instance.UpdateCameraRig(self);
            }
        }