Example #1
0
    protected override void OnUpdate()
    {
        imc.rotDelta         = knInput.KMJControls.RotationDelta.ReadValue <Vector2>();
        imc.zoomDelta        = knInput.KMJControls.ZoomDelta.ReadValue <Vector2>();
        imc.lateralMovement  = knInput.KMJControls.LateralMovement.ReadValue <Vector2>();
        imc.verticalMovement = knInput.KMJControls.VerticalMovement.ReadValue <float>();
        // imc.menuClickDown = knInput.KMJControls.UIClickBtnPress.triggered || imc.menuClickDown;
        // imc.menuClickUp = knInput.KMJControls.UIClickBtnRelease.triggered || imc.menuClickUp;
        // imc.menuToggleDown = knInput.KMJControls.MenuTogglePress.triggered;
        // imc.menuToggleUp = knInput.KMJControls.MenuToggleRelease.triggered;

        imc.rightXRController.connected = knInput.XRControllerRight.Connected.ReadValue <float>() > 0.5f;

        imc.leftXRController.connected = knInput.XRControllerLeft.Connected.ReadValue <float>() > 0.5f;

        SetSingleton <InputManagerComp>(imc);
        imcUpdated = imc;
        imc        = imcFalse;
    }
    protected override void OnUpdate()
    {
        imc = GetSingleton <InputManagerComp>();

        Entities.WithAll <CamControllerTag>().ForEach((CamControllerRefs refs, ref CamControllerComp ccc, ref LocalToWorld lw, ref PhysicsVelocity pv, ref RotationEulerXYZ rot) => {
            if (gmsys.showMenu)
            {
                return;
            }

            t = Time.DeltaTime;

            lv = float3.zero;
            // Debug.Log(imc.lateralMovement + "  " + imc.verticalMovement);

            /* if(Keyboard.current.rightBracketKey.wasPressedThisFrame){
             *  switch (refs.camType) {
             *  case CamControllerAuth.CamType.freeCam:
             *      refs.camType = CamControllerAuth.CamType.overhead;
             *      break;
             *  case CamControllerAuth.CamType.overhead:
             *      refs.camType = CamControllerAuth.CamType.overheadLocked;
             *      break;
             *  case CamControllerAuth.CamType.overheadLocked:
             *      refs.camType = CamControllerAuth.CamType.freeCam;
             *      break;
             *  }
             *  camSwithed = true;
             * }
             *
             * if(Keyboard.current.leftBracketKey.wasPressedThisFrame){
             *  switch (refs.camType) {
             *  case CamControllerAuth.CamType.freeCam:
             *      refs.camType = CamControllerAuth.CamType.overheadLocked;
             *      break;
             *  case CamControllerAuth.CamType.overhead:
             *      refs.camType = CamControllerAuth.CamType.freeCam;
             *      break;
             *  case CamControllerAuth.CamType.overheadLocked:
             *      refs.camType = CamControllerAuth.CamType.overhead;
             *      break;
             *  }
             *  camSwithed = true;
             * } */

            if (camSwithed)
            {
                if (refs.camType == CamControllerAuth.CamType.freeCam)
                {
                    refs.firstPersonCam.enabled = true;
                    refs.overheadCam.enabled    = false;
                }
                else
                {
                    refs.overheadCam.enabled    = true;
                    refs.firstPersonCam.enabled = false;
                    rot.Value = float3.zero;
                }
                camSwithed = false;
            }

            lv    = float3.zero;
            force = ccc.force * t;

            if (math.any(imc.lateralMovement != float2.zero))
            {
                lv += lw.Forward * imc.lateralMovement.y * force;
                lv += lw.Right * imc.lateralMovement.x * force;
            }

            if (imc.verticalMovement != 0)
            {
                lv += lw.Up * imc.verticalMovement * force;
            }

            pv.Linear += lv;

            switch (refs.camType)
            {
            case CamControllerAuth.CamType.freeCam: {
                angleX += -imc.rotDelta.y * ccc.torque * t;
                angleY += imc.rotDelta.x * ccc.torque * t;

                if (angleX > maxXRads)
                {
                    angleX = maxXRads;
                }
                if (angleX < -maxXRads)
                {
                    angleX = -maxXRads;
                }
                if (angleY > maxYRads)
                {
                    angleY -= maxYRads;
                }
                if (angleY < -maxYRads)
                {
                    angleY += maxYRads;
                }

                if (math.any(imc.rotDelta != float2.zero))
                {
                    rot.Value = new float3(angleX, angleY, 0);
                }
                imc.zoomDelta = 0;                                 // no zoom in freecam.

                break;
            }

            case CamControllerAuth.CamType.overhead: {
                angleY += imc.rotDelta.x * ccc.torque * t;

                if (angleY > maxYRads)
                {
                    angleY -= maxYRads;
                }
                if (angleY < -maxYRads)
                {
                    angleY += maxYRads;
                }

                if (imc.rotDelta.x != 0)
                {
                    rot.Value = new float3(0, angleY, 0);
                }

                break;
            }

                /* case CamControllerAuth.CamType.overheadLocked: {
                 *              break;
                 *      } */
            }

            if (imc.zoomDelta.y != 0)
            {
                float3 fcam = refs.firstPersonCam.transform.position;
                float3 ocam = refs.overheadCam.transform.position;

                if (math.distance(fcam, ocam) > ccc.zoomSpeed * imc.zoomDelta.y)
                {
                    refs.overheadCam.transform.position = ocam - math.normalize(ocam - fcam) * (ccc.zoomSpeed * imc.zoomDelta.y);
                }
            }
        });
    } // onupdate