protected override void OnRender(ChromaCanvas canvas)
        {
            if (!Game.InCockpit ||
                Game.DockedOrLanded ||
                Game.FsdJumpType != FsdJumpType.None ||
                Game.Status.HasFlag(Flags.Supercruise))
            {
                return;
            }

            Color lColor;

            if (Game.Status.HasFlag(Flags.LandingGearDeployed))
            {
                StartAnimation();
                lColor = PulseColor(Color.Black, Colors.LandingGearDeployed, TimeSpan.FromSeconds(1));
            }
            else
            {
                StopAnimation();
                lColor = Colors.LandingGearRetracted;
            }

            ApplyColorToBinding(canvas.Keyboard, Miscellaneous.LandingGearToggle, lColor);
        }
Beispiel #2
0
        private void RenderHazardLevel(ChromaCanvas canvas)
        {
            Color          hazardColor;
            TimeSpan       period;
            PulseColorType pulseType;

            switch (_hazardLevel)
            {
            case HazardLevel.Medium:
                hazardColor = GameColors.YellowAlert;
                period      = TimeSpan.FromSeconds(1);
                pulseType   = PulseColorType.Square;
                break;

            case HazardLevel.High:
                hazardColor = GameColors.RedAlert;
                period      = TimeSpan.FromSeconds(0.67);
                pulseType   = PulseColorType.Square;
                break;

            default:
                hazardColor = GameColors.GreenAlert;
                period      = TimeSpan.FromSeconds(1);
                pulseType   = PulseColorType.Triangle;
                break;
            }

            var color = PulseColor(Color.Black, hazardColor, period, pulseType);

            ApplyColorToBinding(canvas.Keyboard, FlightMiscellaneous.HyperSuperCombination, color);
            ApplyColorToBinding(canvas.Keyboard, FlightMiscellaneous.Hyperspace, color);
        }
Beispiel #3
0
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (!Game.InCockpit || Game.FsdJumpType != FsdJumpType.None)
            {
                return;
            }

            var color = Game.Status.HasFlag(Flags.HudInAnalysisMode) ? AnalysisModeColor.Transform(Game.GuiColour) : CombatModeColor;

            ApplyColorToBinding(canvas.Keyboard, ModeSwitches.PlayerHUDModeToggle, color);

            if (!Game.Status.HasFlag(Flags.Docked))
            {
                ApplyColorToBinding(canvas.Keyboard, Weapons.PrimaryFire, color);
                ApplyColorToBinding(canvas.Keyboard, Weapons.SecondaryFire, color);

                Color hColor = color;

                if (Game.Status.HasFlag(Flags.HardpointsDeployed) && !Game.Status.HasFlag(Flags.Supercruise))
                {
                    StartAnimation();
                    hColor = PulseColor(Color.Black, color, TimeSpan.FromSeconds(1));
                }
                else
                {
                    StopAnimation();
                }

                ApplyColorToBinding(canvas.Keyboard, Weapons.DeployHardpointToggle, hColor);
            }
        }
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (Game.ProcessState != _lastState)
            {
                StartAnimation();
                _animC1    = _stateColors[_lastState];
                _animC2    = _stateColors[Game.ProcessState];
                _lastState = Game.ProcessState;
            }

            if (Animated && AnimationElapsed.TotalSeconds >= _fadeSeconds)
            {
                StopAnimation();
            }

            var cLogo = EliteOrange;
            var cBack = Animated
                ? PulseColor(_animC1, _animC2, TimeSpan.FromSeconds(_fadeSeconds * 2))
                : _animC2;

            if (!Game.InMainMenu)
            {
                cLogo = cLogo.Transform(Game.GuiColour);
            }

            canvas.Keyboard.Set(cBack);
            canvas.ChromaLink.Set(cBack);
            var k = canvas.Keyboard;

            k[Key.Logo] = cLogo;
        }
            public void MoveAndRender(ChromaCanvas canvas, TimeSpan deltaT)
            {
                var lastZ = Z;

                Z += _zps * deltaT.TotalSeconds;

                Color c;

                if (lastZ > 0 && Z < 0)
                {
                    // Particle just zoomed by. We apply full brightness.
                    c = _color;
                }
                else
                {
                    // We take the brightness from the nearest point in the light streak.
                    var nearestZ = Math.Min(Math.Abs(lastZ), Math.Abs(Z));
                    c = _color.Transform(1 / (1 + nearestZ));
                }

                Render(canvas.Keyboard, c, lastZ);
                Render(canvas.Mouse, c, lastZ);
                Render(canvas.Mousepad, c);
                Render(canvas.Keypad, c, lastZ);
                Render(canvas.Headset, c);
                Render(canvas.ChromaLink, c, lastZ);
            }
        public async Task SetEffectOnlyAppliesAccessedEffects()
        {
            var chroma = new Mock <IChroma> {
                DefaultValue = DefaultValue.Mock
            };

            var cc = new ChromaCanvas();

            cc.Keyboard.Set(Color.Blue);

            await cc.SetEffect(chroma.Object).ConfigureAwait(false);

            Mock.Get(chroma.Object.Keyboard)
            .Verify(x => x.SetCustomAsync(It.Is <KeyboardCustom>(y => y[0] == Color.Blue)), Times.Once);
            Mock.Get(chroma.Object.Mouse)
            .Verify(x => x.SetGridAsync(It.IsAny <MouseCustom>()), Times.Never);
            Mock.Get(chroma.Object.Headset)
            .Verify(x => x.SetCustomAsync(It.IsAny <HeadsetCustom>()), Times.Never);
            Mock.Get(chroma.Object.Mousepad)
            .Verify(x => x.SetCustomAsync(It.IsAny <MousepadCustom>()), Times.Never);
            Mock.Get(chroma.Object.Keypad)
            .Verify(x => x.SetCustomAsync(It.IsAny <KeypadCustom>()), Times.Never);
            Mock.Get(chroma.Object.ChromaLink)
            .Verify(x => x.SetCustomAsync(It.IsAny <ChromaLinkCustom>()), Times.Never);
        }
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (!Game.InCockpit || Game.Status.HasFlag(Flags.Docked) || Game.FsdJumpType != FsdJumpType.None)
            {
                return;
            }

            var k = canvas.Keyboard;

            k[Key.Escape] = Color.White;

            ApplyColorToBinding(canvas.Keyboard, FlightRotation.All, Color.White);
            ApplyColorToBinding(canvas.Keyboard, FlightThrust.All, Color.Orange);
            ApplyColorToBinding(canvas.Keyboard, AlternateFlightControls.All, Color.White);
            ApplyColorToBinding(canvas.Keyboard, FlightThrottle.All, Color.Yellow);
            ApplyColorToBinding(canvas.Keyboard, FlightLandingOverrides.All, Color.White);
            ApplyColorToBinding(canvas.Keyboard, FlightMiscellaneous.All, Color.Pink);
            ApplyColorToBinding(canvas.Keyboard, Targeting.All, Color.Green);
            ApplyColorToBinding(canvas.Keyboard, Weapons.All, Color.Red);
            ApplyColorToBinding(canvas.Keyboard, Cooling.All, Color.HotPink);

            if (Game.Status.HasFlag(Flags.Supercruise))
            {
                ApplyColorToBinding(canvas.Keyboard, SupercruiseMiscellaneous, Color.Blue);
            }
            else
            {
                ApplyColorToBinding(canvas.Keyboard, Miscellaneous.All, Color.Blue);
            }
        }
        public async Task RazerEffectsAreAccessible()
        {
            var chroma = new Mock <IChroma> {
                DefaultValue = DefaultValue.Mock
            };

            var cc = new ChromaCanvas();

            cc.Keyboard.Set(Color.Blue);
            cc.Mouse.Set(Color.Green);
            cc.Headset.Set(Color.HotPink);
            cc.Mousepad.Set(Color.Orange);
            cc.Keypad.Set(Color.Pink);
            cc.ChromaLink.Set(Color.Purple);

            await cc.SetEffect(chroma.Object).ConfigureAwait(false);

            Mock.Get(chroma.Object.Keyboard)
            .Verify(x => x.SetCustomAsync(It.Is <KeyboardCustom>(y => y[0] == Color.Blue)));
            Mock.Get(chroma.Object.Mouse)
            .Verify(x => x.SetGridAsync(It.Is <MouseCustom>(y => y[0] == Color.Green)));
            Mock.Get(chroma.Object.Headset)
            .Verify(x => x.SetCustomAsync(It.Is <HeadsetCustom>(y => y[0] == Color.HotPink)));
            Mock.Get(chroma.Object.Mousepad)
            .Verify(x => x.SetCustomAsync(It.Is <MousepadCustom>(y => y[0] == Color.Orange)));
            Mock.Get(chroma.Object.Keypad)
            .Verify(x => x.SetCustomAsync(It.Is <KeypadCustom>(y => y[0] == Color.Pink)));
            Mock.Get(chroma.Object.ChromaLink)
            .Verify(x => x.SetCustomAsync(It.Is <ChromaLinkCustom>(y => y[0] == Color.Purple)));
        }
Beispiel #9
0
        protected override void OnRender(ChromaCanvas canvas, object state)
        {
            var rs = (LayerRenderState)state ?? throw new ArgumentNullException(nameof(state));

            Game   = rs.GameState;
            Colors = rs.Colors;
            OnRender(canvas);
        }
Beispiel #10
0
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (!Game.InSrv)
            {
                return;
            }

            ApplyColorToBinding(canvas.Keyboard, DrivingModeSwitches.All, Colors.VehicleModeSwitches);
        }
Beispiel #11
0
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (!Game.InCockpit || (Game.FsdJumpType != FsdJumpType.None && !Game.InWitchSpace))
            {
                return;
            }

            ApplyColorToBinding(canvas.Keyboard, ModeSwitches.All, Colors.VehicleModeSwitches);
        }
Beispiel #12
0
            public void MoveAndRender(ChromaCanvas canvas, TimeSpan deltaT)
            {
                var lastZ = Z;

                Z += _zps * deltaT.TotalSeconds;

                var c = _color.Transform(1 / (0.1 + Math.Abs(Z)));

                Render(canvas.Keyboard, c, lastZ);
                Render(canvas.ChromaLink, c);
            }
            public void MoveAndDraw(TimeSpan deltaT, ChromaCanvas canvas)
            {
                canvas.Keyboard.Set(Color.Black);
                canvas.ChromaLink.Set(Color.Black);

                Trim();

                foreach (var star in _particles)
                {
                    star.MoveAndRender(canvas, deltaT);
                }
            }
Beispiel #14
0
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (Game.AttackTarget == UnderAttack.AttackTarget.You && Game.AttackTargetChange > _lastUnderAttack)
            {
                _lastUnderAttack = Game.AttackTargetChange;
                _underAttackFade = _lastUnderAttack + _underAttackDuration;
            }

            var underAttack = Now < _underAttackFade;
            var inDanger    = Game.Status.HasFlag(Flags.IsInDanger);
            var otherDanger = Game.Status.HasFlag(Flags.Overheating);

            if (underAttack || inDanger || otherDanger)
            {
                StartAnimation();
            }
            else
            {
                StopAnimation();
                return;
            }

            var k = canvas.Keyboard;

            if (underAttack || otherDanger)
            {
                var flarePct = PulseColor(Color.Black, Color.White, _fastPulse).R / 255.0;

                if (!otherDanger)
                {
                    var fade = (_underAttackFade - Now).TotalSeconds / _underAttackDuration.TotalSeconds;
                    flarePct = flarePct * fade * fade;
                }

                var c = GameColors.RedAlert.Transform(flarePct);

                var cLogo = k[Key.Logo];
                canvas.Keyboard.Max(c);
                k[Key.Logo] = cLogo;

                canvas.Mouse.Combine(GameColors.RedAlert, flarePct);
                canvas.Mousepad.Combine(GameColors.RedAlert, flarePct);
                canvas.Keypad.Max(c);
                canvas.Headset.Combine(GameColors.RedAlert, flarePct);
                canvas.ChromaLink.Combine(GameColors.RedAlert, flarePct);
            }

            if (inDanger)
            {
                k[Key.Logo] = PulseColor(k[Key.Logo], GameColors.RedAlert, _slowPulse);
            }
        }
Beispiel #15
0
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (Game.Status.GuiFocus != GuiFocus.GalaxyMap)
            {
                return;
            }

            var k = canvas.Keyboard;

            k[Key.Escape] = Colors.InterfaceMode;

            ApplyColorToBinding(canvas.Keyboard, GalaxyMap.All, Colors.InterfaceMode);
        }
Beispiel #16
0
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (Game.AtHelm && !Game.DockedOrLanded && Game.Status.GuiFocus == GuiFocus.None)
            {
                return;
            }

            var k = canvas.Keyboard;

            k[Key.Escape] = Colors.InterfaceMode;

            ApplyColorToBinding(canvas.Keyboard, InterfaceMode.All, Colors.InterfaceMode);
        }
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (Game.InCockpit && !Game.Status.HasFlag(Flags.Docked) && Game.Status.GuiFocus == GuiFocus.None)
            {
                return;
            }

            var k = canvas.Keyboard;

            k[Key.Escape] = Color.White;

            ApplyColorToBinding(canvas.Keyboard, InterfaceMode.All, Color.White);
        }
Beispiel #18
0
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (!Game.InCockpit || Game.FsdJumpType != FsdJumpType.None)
            {
                return;
            }

            var colorOn = Game.Status.HasFlag(Flags.HudInAnalysisMode) ? Game.Colors.AnalysisMode : Colors.HardpointsToggle;

            ApplyColorToBinding(canvas.Keyboard, ModeSwitches.PlayerHUDModeToggle, colorOn);

            if (Game.DockedOrLanded)
            {
                return;
            }

            ApplyColorToBinding(canvas.Keyboard, Weapons.PrimaryFire, colorOn);
            ApplyColorToBinding(canvas.Keyboard, Weapons.SecondaryFire, colorOn);

            var hardpointsDeployed = Game.Status.HasFlag(Flags.HardpointsDeployed) && !Game.Status.HasFlag(Flags.Supercruise);

            Color hColor;

            if (hardpointsDeployed)
            {
                StartAnimation();
                hColor = PulseColor(Color.Black, colorOn, TimeSpan.FromSeconds(1));
            }
            else
            {
                StopAnimation();
                hColor = colorOn;
            }

            ApplyColorToBinding(canvas.Keyboard, Weapons.DeployHardpointToggle, hColor);

            var c = Game.Status.HasFlag(Flags.HudInAnalysisMode) ? Game.Colors.AnalysisMode : Game.Colors.Hud;

            if (!hardpointsDeployed)
            {
                c = c.Transform(Colors.DeviceDimBrightness);
            }

            canvas.Mouse.Set(c);
            canvas.Mousepad.Set(c);
            canvas.Headset.Set(c);
            canvas.ChromaLink.Set(c);
        }
Beispiel #19
0
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (!Game.InCockpit || Game.DockedOrLanded || Game.FsdJumpType != FsdJumpType.None)
            {
                return;
            }

            var cSys = Colors.PowerDistributorScale[Game.Status.Pips.Sys];
            var cEng = Colors.PowerDistributorScale[Game.Status.Pips.Eng];
            var cWep = Colors.PowerDistributorScale[Game.Status.Pips.Wep];

            ApplyColorToBinding(canvas.Keyboard, Miscellaneous.IncreaseSystemsPower, cSys);
            ApplyColorToBinding(canvas.Keyboard, Miscellaneous.IncreaseWeaponsPower, cWep);
            ApplyColorToBinding(canvas.Keyboard, Miscellaneous.IncreaseEnginesPower, cEng);
            ApplyColorToBinding(canvas.Keyboard, Miscellaneous.ResetPowerDistribution, Colors.PowerDistributorReset);
        }
Beispiel #20
0
        protected override void OnRender(ChromaCanvas canvas)
        {
            var cLogo = EliteOrange;
            var cBack = BackgroundColor;

            if (!Game.InMainMenu)
            {
                cLogo = cLogo.Transform(Game.GuiColour);
                cBack = cBack.Transform(Game.GuiColour);
            }

            canvas.Keyboard.Set(cBack);
            var k = canvas.Keyboard;

            k[Key.Logo] = cLogo;
        }
Beispiel #21
0
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (!Game.InCockpit || Game.Status.HasFlag(Flags.Docked) || Game.FsdJumpType != FsdJumpType.None)
            {
                return;
            }

            var cSys = _pips[Game.Status.Pips.Sys];
            var cEng = _pips[Game.Status.Pips.Eng];
            var cWep = _pips[Game.Status.Pips.Wep];

            ApplyColorToBinding(canvas.Keyboard, Miscellaneous.IncreaseSystemsPower, cSys);
            ApplyColorToBinding(canvas.Keyboard, Miscellaneous.IncreaseWeaponsPower, cWep);
            ApplyColorToBinding(canvas.Keyboard, Miscellaneous.IncreaseEnginesPower, cEng);
            ApplyColorToBinding(canvas.Keyboard, Miscellaneous.ResetPowerDistribution, new Color(0.5, 0.5, 0.5));
        }
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (!Game.InSrv)
            {
                return;
            }

            var cSys = Colors.PowerDistributorScale[Game.Status.Pips.Sys];
            var cEng = Colors.PowerDistributorScale[Game.Status.Pips.Eng];
            var cWep = Colors.PowerDistributorScale[Game.Status.Pips.Wep];

            ApplyColorToBinding(canvas.Keyboard, DrivingMiscellaneous.IncreaseSystemsPower, cSys);
            ApplyColorToBinding(canvas.Keyboard, DrivingMiscellaneous.IncreaseWeaponsPower, cWep);
            ApplyColorToBinding(canvas.Keyboard, DrivingMiscellaneous.IncreaseEnginesPower, cEng);
            ApplyColorToBinding(canvas.Keyboard, DrivingMiscellaneous.ResetPowerDistribution, Colors.PowerDistributorReset);
        }
Beispiel #23
0
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (!Game.InSrv)
            {
                return;
            }

            var lColor = Game.Status.HasFlag(Flags.LightsOn)
                ? (Game.Status.HasFlag(Flags.SrvHighBeam) ? Colors.VehicleLightsHighBeam : Colors.VehicleLightsMidBeam)
                : Colors.VehicleLightsOff;

            ApplyColorToBinding(canvas.Keyboard, Driving.Headlights, lColor);

            var nColor = Game.Status.HasFlag(Flags.NightVision) ? Colors.VehicleLightsHighBeam : Colors.VehicleLightsOff;

            ApplyColorToBinding(canvas.Keyboard, Miscellaneous.NightVisionToggle, nColor);
        }
Beispiel #24
0
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (!Game.InCockpit || Game.FsdJumpType != FsdJumpType.None)
            {
                return;
            }

            var lColor = Game.Status.HasFlag(Flags.LightsOn) ? Colors.VehicleLightsHighBeam : Colors.VehicleLightsOff;

            ApplyColorToBinding(canvas.Keyboard, Miscellaneous.ShipSpotLightToggle, lColor);

            if (!Game.DockedOrLanded)
            {
                var nColor = Game.Status.HasFlag(Flags.NightVision) ? Colors.VehicleLightsHighBeam : Colors.VehicleLightsOff;
                ApplyColorToBinding(canvas.Keyboard, Miscellaneous.NightVisionToggle, nColor);
            }
        }
Beispiel #25
0
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (!Game.Status.HasFlag(Flags.Landed))
            {
                StopAnimation();
                return;
            }

            StartAnimation();

            var k = canvas.Keyboard;

            k[Key.Escape] = Colors.InterfaceMode;

            var c = PulseColor(Color.Black, Colors.VehicleThrust, TimeSpan.FromSeconds(1));

            ApplyColorToBinding(canvas.Keyboard, FlightThrust.Up, c);
        }
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (!Game.InCockpit || Game.DockedOrLanded || Game.FsdJumpType != FsdJumpType.None)
            {
                return;
            }

            var k = canvas.Keyboard;

            k[Key.Escape] = Colors.InterfaceMode;

            ApplyColorToBinding(canvas.Keyboard, FlightRotation.All, Colors.VehicleRotation);
            ApplyColorToBinding(canvas.Keyboard, FlightThrust.All, Colors.VehicleThrust);
            ApplyColorToBinding(canvas.Keyboard, AlternateFlightControls.All, Colors.VehicleAlternate);
            ApplyColorToBinding(canvas.Keyboard, FlightThrottle.All, Colors.VehicleThrottle);
            ApplyColorToBinding(canvas.Keyboard, FlightLandingOverrides.All, Colors.VehicleAlternate);
            ApplyColorToBinding(canvas.Keyboard, FlightMiscellaneous.All, Colors.VehicleMiscellaneous);
            ApplyColorToBinding(canvas.Keyboard, Targeting.All, Colors.VehicleTargeting);
            ApplyColorToBinding(canvas.Keyboard, Weapons.All, Colors.VehicleWeapons);
            ApplyColorToBinding(canvas.Keyboard, Cooling.All, Colors.VehicleCooling);

            if (Game.Status.HasFlag(Flags.Supercruise))
            {
                ApplyColorToBinding(canvas.Keyboard, SupercruiseMiscellaneous, Colors.Miscellaneous);
                ApplyColorToBinding(canvas.Keyboard, FullSpectrumSystemScanner.Enter, Colors.FullSpectrumSystemScanner);
            }
            else
            {
                ApplyColorToBinding(canvas.Keyboard, Miscellaneous.All, Colors.Miscellaneous);
            }

            if (Game.Status.HasFlag(Flags.FsdCharging))
            {
                StartAnimation();
                var jumpColor = PulseColor(Colors.FrameShiftDriveControls, Color.Black, TimeSpan.FromSeconds(1));
                ApplyColorToBinding(canvas.Keyboard, FlightMiscellaneous.HyperSuperCombination, jumpColor);
                ApplyColorToBinding(canvas.Keyboard, FlightMiscellaneous.Supercruise, jumpColor);
                ApplyColorToBinding(canvas.Keyboard, FlightMiscellaneous.Hyperspace, jumpColor);
            }
            else
            {
                StopAnimation();
            }
        }
Beispiel #27
0
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (!Game.InCockpit || Game.Status.HasFlag(Flags.Docked) || Game.FsdJumpType != FsdJumpType.None)
            {
                return;
            }

            var k = canvas.Keyboard;

            k[Key.Escape] = Color.White;

            ApplyColorToBinding(canvas.Keyboard, FlightRotation.All, Color.White);
            ApplyColorToBinding(canvas.Keyboard, FlightThrust.All, Color.Orange);
            ApplyColorToBinding(canvas.Keyboard, AlternateFlightControls.All, Color.White);
            ApplyColorToBinding(canvas.Keyboard, FlightThrottle.All, Color.Yellow);
            ApplyColorToBinding(canvas.Keyboard, FlightLandingOverrides.All, Color.White);
            ApplyColorToBinding(canvas.Keyboard, FlightMiscellaneous.All, Color.Pink);
            ApplyColorToBinding(canvas.Keyboard, Targeting.All, Color.Green);
            ApplyColorToBinding(canvas.Keyboard, Weapons.All, Color.Red);
            ApplyColorToBinding(canvas.Keyboard, Cooling.All, Color.HotPink);

            if (Game.Status.HasFlag(Flags.Supercruise))
            {
                ApplyColorToBinding(canvas.Keyboard, SupercruiseMiscellaneous, Color.Blue);
                ApplyColorToBinding(canvas.Keyboard, FullSpectrumSystemScanner.Enter, Color.Green);
            }
            else
            {
                ApplyColorToBinding(canvas.Keyboard, Miscellaneous.All, Color.Blue);
            }

            if (Game.Status.HasFlag(Flags.FsdCharging))
            {
                StartAnimation();
                var jumpColor = PulseColor(Color.Pink, Color.Black, TimeSpan.FromSeconds(1));
                ApplyColorToBinding(canvas.Keyboard, FlightMiscellaneous.HyperSuperCombination, jumpColor);
                ApplyColorToBinding(canvas.Keyboard, FlightMiscellaneous.Supercruise, jumpColor);
                ApplyColorToBinding(canvas.Keyboard, FlightMiscellaneous.Hyperspace, jumpColor);
            }
            else
            {
                StopAnimation();
            }
        }
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (!Game.InSrv)
            {
                return;
            }

            var colorOn = Game.Status.HasFlag(Flags.HudInAnalysisMode) ? Game.Colors.AnalysisMode : Colors.HardpointsToggle;

            ApplyColorToBinding(canvas.Keyboard, DrivingModeSwitches.PlayerHUDModeToggle, colorOn);

            ApplyColorToBinding(canvas.Keyboard, Driving.PrimaryFire, colorOn);
            ApplyColorToBinding(canvas.Keyboard, Driving.SecondaryFire, colorOn);
            ApplyColorToBinding(canvas.Keyboard, Driving.CycleFireGroupNext, colorOn);
            ApplyColorToBinding(canvas.Keyboard, Driving.CycleFireGroupPrevious, colorOn);

            var hardpointsDeployed = !Game.Status.HasFlag(Flags.SrvTurretRetracted);

            Color hColor;

            if (hardpointsDeployed)
            {
                StartAnimation();
                hColor = PulseColor(Color.Black, colorOn, TimeSpan.FromSeconds(1));
            }
            else
            {
                StopAnimation();
                hColor = colorOn;
            }

            ApplyColorToBinding(canvas.Keyboard, Driving.ToggleTurret, hColor);

            var colorOff = Game.Status.HasFlag(Flags.HudInAnalysisMode)
                ? Game.Colors.AnalysisMode.Transform(Colors.DeviceDimBrightness)
                : Game.Colors.Hud.Transform(Colors.DeviceDimBrightness);

            var c = hardpointsDeployed ? colorOn : colorOff;

            canvas.Mouse.Set(c);
            canvas.Mousepad.Set(c);
            canvas.Headset.Set(c);
            canvas.ChromaLink.Set(c);
        }
Beispiel #29
0
        // InBackground -> InForeground => HUD -> Black
        // InForeground -> InBackground => Black -> HUD
        // NotRunning   -> InBackground => Black -> HUD
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (Game.ProcessState == Elite.GameProcessState.NotRunning)
            {
                StopAnimation();
                _inBackground = false;
                return;
            }

            var inBackground = Game.ProcessState == Elite.GameProcessState.InBackground;

            if (inBackground != _inBackground)
            {
                StartAnimation();
                _inBackground = inBackground;
            }

            if (Animated && AnimationElapsed >= _fadeDuration)
            {
                StopAnimation();
            }

            if (!inBackground && !Animated)
            {
                return;
            }

            var pct = Animated
                ? Math.Min(1, AnimationElapsed.TotalSeconds / _fadeDuration.TotalSeconds)
                : 1;

            if (!inBackground)
            {
                pct = 1 - pct;
            }

            canvas.Keyboard.Combine(Game.Colors.Hud, pct);
            canvas.Mouse.Combine(Game.Colors.Hud, pct);
            canvas.Mousepad.Combine(Game.Colors.Hud, pct);
            canvas.Keypad.Combine(Game.Colors.Hud, pct);
            canvas.Headset.Combine(Game.Colors.Hud, pct);
            canvas.ChromaLink.Combine(Game.Colors.Hud, pct);
        }
Beispiel #30
0
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (Game.Status.GuiFocus != GuiFocus.FssMode)
            {
                return;
            }

            var k = canvas.Keyboard;

            k[Key.Escape] = Color.White;

            ApplyColorToBinding(canvas.Keyboard, FssCamera, Color.Green);
            ApplyColorToBinding(canvas.Keyboard, FssZoom, Color.Blue);
            ApplyColorToBinding(canvas.Keyboard, FssTuning, Color.Purple);
            ApplyColorToBinding(canvas.Keyboard, FullSpectrumSystemScanner.DiscoveryScan, AnalysisModeColor);
            ApplyColorToBinding(canvas.Keyboard, FullSpectrumSystemScanner.Quit, Color.White);
            ApplyColorToBinding(canvas.Keyboard, FullSpectrumSystemScanner.Target, Color.Yellow);
            ApplyColorToBinding(canvas.Keyboard, FullSpectrumSystemScanner.ShowHelp, EliteOrange);
        }