3D Gauge Ball & Cylinder and Colour Effects (#891)

* M2K ADI added
* Viper ADI updated, and Apache ADI images adjusted.
Rotation capability given to the Gauge Image.

* Adjustments to the F-16, M2000C and AH-64D ADIs.  Most of the work done on the CustomGaugeBall.
* Addition of the GaugeCylinder, and over-hauled the FA-18C SAI and most of the graphics.  Add the capability of the CustomGaugeBall to have an alternate lighting colour.

* A-10C ADI complete
* Implement ball and cylinder brightness, and multiple adjustments to teh altered ADIs to implement these.
* EffectControlAdjuster Enable/Disable function added
* Test implementation of an x/y/z interface element on the M2000C in an attempt to reduce the number of ball renders.
* Fix for Bug where reflections were not being scaled
* Fix for Incorrect ADI Pitch calibration on the M2000C
* Work on the CustomerBallGauge
* Adding calibration to the Custom 3D Gauges
"Missing Image" image changed to have words, and converted to xaml to improve scaling.
UH-60L VSI completion including interface changes.
* 1.  Added SoftInterface capability to AutoBinding SupportedInterfaces
3. Added VSI LEDs to UH-60L interface
4. UH-60L VSI now autobinds to H-60 variant Soft Interfaces.

Author: BlueFinBima

Aircraft A-10C/Aircraft A-10C.csproj

@@ -915,6 +915,9 @@
     <Content Include="Templates\Base\A-10C\8 Components\Keys\UFC_IFF.htpl">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="Templates\Base\A-10C\3 Gauges\1 Primary Instruments\ADI - V1.htpl">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
   </ItemGroup>
   <Import Project="..\Helios.targets" />
   <PropertyGroup>

Aircraft A-10C/Templates/Base/A-10C/3 Gauges/1 Primary Instruments/ADI - V1.htpl

@@ -0,0 +1,13 @@
+<ControlTemplate>
+	<Name>ADI (2D)</Name>
+	<Category>A-10C Warthog</Category>
+	<TypeIdentifier>Helios.A10.ADI.V1</TypeIdentifier>
+	<Template>
+		<TemplateValues>
+			<Location>0,0</Location>
+			<Size>350,350</Size>
+			<Hidden>False</Hidden>
+			<Children />
+		</TemplateValues>
+	</Template>
+</ControlTemplate>

Aircraft AH-64D Plugin/Aircraft AH-64D Plugin.csproj

@@ -63,7 +63,7 @@
     </Content>
     <Resource Include="Interfaces\ExportFunctions.lua" />
     <Resource Include="Images\SAI\adi_off_flag.png" />
-    <Resource Include="Images\SAI\adi_ball.png" />
+    <Resource Include="Images\SAI\V1\adi_ball.png" />
     <Content Include="Templates\Base\AH-64D\0 Altimeter.htpl">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
@@ -126,6 +126,7 @@
     <Compile Include="Gauges\MFD\MFD.cs" />
     <Compile Include="Gauges\Power\PowerLever.cs" />
     <Compile Include="Gauges\SAI\SAI.cs" />
+    <Compile Include="Gauges\SAI\SAI_V1.cs" />
     <Compile Include="Gauges\TEDAC\TEDAC.cs" />
     <Compile Include="Interfaces\AH-64DInterface.cs" />
     <Compile Include="Interfaces\Functions\AH-64DFunction.cs" />
@@ -369,6 +370,27 @@
   <ItemGroup>
     <None Include="app.config" />
     <None Include="packages.config" />
+    <Content Include="Templates\Base\AH-64D\0 Standby Attitude Indicator-V1.htpl">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+  <ItemGroup>
+    <Resource Include="Images\SAI\adi_ball.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Resource>
+  </ItemGroup>
+  <ItemGroup>
+    <Resource Include="Images\SAI\adi_ball1.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Resource>
+  </ItemGroup>
+  <ItemGroup>
+    <Resource Include="Images\SAI\adi_ball2.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Resource>
   </ItemGroup>
   <Import Project="..\HeliosPlugin.targets" />
 </Project>

Aircraft AH-64D Plugin/Gauges/SAI/SAI.cs

@@ -17,47 +17,58 @@
 namespace GadrocsWorkshop.Helios.Gauges.AH64D.SAI
 {
     using GadrocsWorkshop.Helios.ComponentModel;
+    using GadrocsWorkshop.Helios.Util;
     using System;
+    using System.Globalization;
     using System.Windows;
     using System.Windows.Media;
+    using System.Windows.Media.Media3D;
 
-    [HeliosControl("Helios.AH64D.SAI", "Standby Attitude Indicator", "AH-64D", typeof(GaugeRenderer),HeliosControlFlags.NotShownInUI)]
+    [HeliosControl("Helios.AH64D.SAI", "Standby Attitude Indicator", "AH-64D Apache", typeof(GaugeRenderer), HeliosControlFlags.NotShownInUI)]
     public class SAI : BaseGauge
     {
         private HeliosValue _pitch;
         private HeliosValue _roll;
+        private HeliosValue _rotationValue;
         private HeliosValue _pitchAdjustment;
         private HeliosValue _slipBall;
         private HeliosValue _turnIndicator;
 
         private HeliosValue _offFlag;
 
         private GaugeImage _offFlagImage;
-
-        private GaugeNeedle _ball;
+        private GaugeBall _ball;
         private GaugeNeedle _bankNeedle;
         private GaugeNeedle _wingsNeedle;
         private GaugeNeedle _slipBallNeedle;
         private GaugeNeedle _TurnMarker;
 
-        private CalibrationPointCollectionDouble _pitchCalibration;
+        private CalibrationPointCollectionDouble _axisCalibration;
         private CalibrationPointCollectionDouble _pitchAdjustCalibaration;
         private CalibrationPointCollectionDouble _slipBallCalibration;
 
+        private bool _suppressScale = false;
+
+
         public SAI()
             : base("Standby Attitude Indicator", new Size(350, 350))
         {
             Point center = new Point(177d, 163d);
 
-            _pitchCalibration = new CalibrationPointCollectionDouble(-360d, -1066d, 360d, 1066d);
-            _ball = new GaugeNeedle("{AH-64D}/Images/SAI/adi_ball.png", center, new Size(198d, 1160d), new Point(99d, 580d));
-            _ball.Clip = new EllipseGeometry(center, 99d, 99d);
+            _axisCalibration = new CalibrationPointCollectionDouble(-360d, -360d, 360d, 360d);
+
+            _ball = new GaugeBall("{AH-64D}/Images/SAI/adi_ball1.xaml", new Point(72d, 58d), new Size(210d, 210d), 0d, 0d, -90d, 38d);
             Components.Add(_ball);
+            _ball.Y = -0.001d;
+            _ball.Z = 0.001d;
+            _ball.LightingBrightness = 1.0d;
 
             _pitchAdjustCalibaration = new CalibrationPointCollectionDouble(0.11d, -36d, 0.89d, 36d);
             _wingsNeedle = new GaugeNeedle("{AH-64D}/Images/SAI/adi_wings.xaml", new Point(99d, 158d), new Size(157d, 31d), new Point(0d, 0d));
             Components.Add(_wingsNeedle);
 
+            Components.Add(new GaugeImage("{helios}/Gauges/Common/Circular-Shading.xaml", new Rect(80, 65, 198d, 198d)));
+
             Components.Add(new GaugeImage("{AH-64D}/Images/SAI/adi_innermost_ring.xaml", new Rect(65d, 52d, 224d, 224d)));
             Components.Add(new GaugeImage("{AH-64D}/Images/SAI/adi_inner_ring.xaml", new Rect(30d, 23d, 287d, 305d)));
 
@@ -81,6 +92,11 @@ public SAI()
 
             Components.Add(new GaugeImage("{AH-64D}/Images/SAI/adi_bezel.png", new Rect(0d, 0d, 350d, 350d)));
 
+            foreach (GaugeComponent gc in Components)
+            {
+                gc.EffectsExclusion = this.EffectsExclusion;
+            }
+
             _slipBall = new HeliosValue(this, new BindingValue(0d), "Standby Attitude Indicator", "Slip Ball Offset", "Side slip indicator offset from the center of the tube.", "(-1 to 1) -1 full left and 1 is full right.", BindingValueUnits.Numeric);
             _slipBall.Execute += new HeliosActionHandler(SlipBall_Execute);
             Actions.Add(_slipBall);
@@ -93,17 +109,22 @@ public SAI()
             _offFlag.Execute += new HeliosActionHandler(OffFlag_Execute);
             Actions.Add(_offFlag);
 
-            _pitch = new HeliosValue(this, new BindingValue(0d), "Standby Attitude Indicator", "Pitch", "Current ptich of the aircraft.", "(0 - 360)", BindingValueUnits.Degrees);
+            _pitch = new HeliosValue(this, new BindingValue(0d), "Standby Attitude Indicator", "Pitch", "Current pitch of the aircraft.", "(-90 to +90)", BindingValueUnits.Degrees);
             _pitch.Execute += new HeliosActionHandler(Pitch_Execute);
             Actions.Add(_pitch);
 
             _pitchAdjustment = new HeliosValue(this, new BindingValue(0d), "Standby Attitude Indicator", "SAI Pitch adjustment offset", "Location of pitch reference wings.", "(-1 to 1) 1 full up and -1 is full down.", BindingValueUnits.Numeric);
             _pitchAdjustment.Execute += new HeliosActionHandler(PitchAdjust_Execute);
             Actions.Add(_pitchAdjustment);
 
-            _roll = new HeliosValue(this, new BindingValue(0d), "Standby Attitude Indicator", "Bank", "Current bank of the aircraft.", "(0 - 360)", BindingValueUnits.Degrees);
+            _roll = new HeliosValue(this, new BindingValue(0d), "Standby Attitude Indicator", "Bank", "Current bank of the aircraft.", "(-180 to +180)", BindingValueUnits.Degrees);
             _roll.Execute += new HeliosActionHandler(Bank_Execute);
             Actions.Add(_roll);
+
+            _rotationValue = new HeliosValue(this, new BindingValue(""), "Standby Attitude Indicator", "ADI ball rotation", "X/Y/Z angle changes for the ADI ball.", "Text containing three numbers x;y;z", BindingValueUnits.Text);
+            _rotationValue.Execute += new HeliosActionHandler(Rotation_Execute);
+            Actions.Add(_rotationValue);
+
         }
 
 
@@ -122,7 +143,7 @@ void OffFlag_Execute(object action, HeliosActionEventArgs e)
         void Pitch_Execute(object action, HeliosActionEventArgs e)
         {
             _pitch.SetValue(e.Value, e.BypassCascadingTriggers);
-            _ball.VerticalOffset = _pitchCalibration.Interpolate(e.Value.DoubleValue);
+            _ball.X = e.Value.DoubleValue;
         }
         void PitchAdjust_Execute(object action, HeliosActionEventArgs e)
         {
@@ -132,14 +153,68 @@ void PitchAdjust_Execute(object action, HeliosActionEventArgs e)
         void Bank_Execute(object action, HeliosActionEventArgs e)
         {
             _roll.SetValue(e.Value, e.BypassCascadingTriggers);
-            _ball.Rotation = -e.Value.DoubleValue;
-            _bankNeedle.Rotation = -e.Value.DoubleValue;
+            _ball.Z = e.Value.DoubleValue;
+            _bankNeedle.Rotation = e.Value.DoubleValue;
+        }
+        void Rotation_Execute(object action, HeliosActionEventArgs e)
+        {
+            _rotationValue.SetValue(e.Value, e.BypassCascadingTriggers);
+            string[] parts;
+            parts = Tokenizer.TokenizeAtLeast(e.Value.StringValue, 3, ';');
+            double.TryParse(parts[0], NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out double x);
+            double.TryParse(parts[1], NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out double y);
+            double.TryParse(parts[2], NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out double z);
+            _ball.Rotation3D = new Point3D(x, y, -z);
+            _bankNeedle.Rotation = z;
         }
         void turnIndicator_Execute(object action, HeliosActionEventArgs e)
         {
             _turnIndicator.SetValue(e.Value, e.BypassCascadingTriggers);
             _TurnMarker.HorizontalOffset = _slipBallCalibration.Interpolate(e.Value.DoubleValue);
         }
+        public override bool EffectsExclusion
+        {
+            get => base.EffectsExclusion;
+            set
+            {
+                if (!base.EffectsExclusion.Equals(value))
+                {
+                    base.EffectsExclusion = value;
+                    OnPropertyChanged("EffectsExclusion", !value, value, true);
+                }
+            }
+        }
+        public override void ScaleChildren(double scaleX, double scaleY)
+        {
+            if (!_suppressScale)
+            {
+                _ball.ScaleChildren(scaleX, scaleY);
+                _suppressScale = false;
+            }
+            base.ScaleChildren(scaleX, scaleY);
+        }
+        protected override void PostUpdateRectangle(Rect previous, Rect current)
+        {
+            _suppressScale = false;
+            if (!previous.Equals(new Rect(0, 0, 0, 0)) && !(previous.Width == current.Width && previous.Height == current.Height))
+            {
+                _ball.ScaleChildren(current.Width / previous.Width, current.Height / previous.Height);
+                _suppressScale = true;
+            }
+        }
+
+        public override void Reset()
+        {
+            base.Reset();
+            _ball.Reset();
+            _pitch.SetValue(new BindingValue(0d), true);
+            _roll.SetValue(new BindingValue(0d), true);
+            _rotationValue.SetValue(new BindingValue("0;0;0"), true);
+            _pitchAdjustment.SetValue(new BindingValue(0d), true);
+            _slipBall.SetValue(new BindingValue(0d), true);
+            _offFlag.SetValue(new BindingValue(false), true);
+            _pitchAdjustment.SetValue(new BindingValue(0d), true);
+        }
 
     }
 }

Aircraft AH-64D Plugin/Gauges/SAI/SAI_V1.cs

@@ -0,0 +1,145 @@
+//  Copyright 2014 Craig Courtney
+//  Copyright 2022 Helios Contributors
+//    
+//  Helios is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  Helios is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+namespace GadrocsWorkshop.Helios.Gauges.AH64D.SAI
+{
+    using GadrocsWorkshop.Helios.ComponentModel;
+    using System;
+    using System.Windows;
+    using System.Windows.Media;
+
+    [HeliosControl("Helios.AH64D.SAI.V1", "Standby Attitude Indicator (V1)", "AH-64D Apache", typeof(GaugeRenderer),HeliosControlFlags.NotShownInUI)]
+    public class SAI_V1 : BaseGauge
+    {
+        private HeliosValue _pitch;
+        private HeliosValue _roll;
+        private HeliosValue _pitchAdjustment;
+        private HeliosValue _slipBall;
+        private HeliosValue _turnIndicator;
+
+        private HeliosValue _offFlag;
+
+        private GaugeImage _offFlagImage;
+
+        private GaugeNeedle _ball;
+        private GaugeNeedle _bankNeedle;
+        private GaugeNeedle _wingsNeedle;
+        private GaugeNeedle _slipBallNeedle;
+        private GaugeNeedle _TurnMarker;
+
+        private CalibrationPointCollectionDouble _pitchCalibration;
+        private CalibrationPointCollectionDouble _pitchAdjustCalibaration;
+        private CalibrationPointCollectionDouble _slipBallCalibration;
+
+        public SAI_V1()
+            : base("Standby Attitude Indicator (V1)", new Size(350, 350))
+        {
+            Point center = new Point(177d, 163d);
+
+            _pitchCalibration = new CalibrationPointCollectionDouble(-360d, -1066d, 360d, 1066d);
+            _ball = new GaugeNeedle("{AH-64D}/Images/SAI/V1/adi_ball.png", center, new Size(198d, 1160d), new Point(99d, 580d));
+            _ball.Clip = new EllipseGeometry(center, 99d, 99d);
+            Components.Add(_ball);
+
+            _pitchAdjustCalibaration = new CalibrationPointCollectionDouble(0.11d, -36d, 0.89d, 36d);
+            _wingsNeedle = new GaugeNeedle("{AH-64D}/Images/SAI/adi_wings.xaml", new Point(99d, 158d), new Size(157d, 31d), new Point(0d, 0d));
+            Components.Add(_wingsNeedle);
+
+            Components.Add(new GaugeImage("{AH-64D}/Images/SAI/adi_innermost_ring.xaml", new Rect(65d, 52d, 224d, 224d)));
+            Components.Add(new GaugeImage("{AH-64D}/Images/SAI/adi_inner_ring.xaml", new Rect(30d, 23d, 287d, 305d)));
+
+            _bankNeedle = new GaugeNeedle("{AH-64D}/Images/SAI/adi_arrow.xaml", center, new Size(17d, 110d), new Point(8.5d, 110d));
+            Components.Add(_bankNeedle);
+
+            _slipBallCalibration = new CalibrationPointCollectionDouble(-1d, -26d, 1d, 26d);
+            _slipBallNeedle = new GaugeNeedle("{AH-64D}/Images/SAI/adi_slip_ball.xaml", new Point(176d, 297d), new Size(14d, 14d), new Point(7d, 7d));
+            Components.Add(_slipBallNeedle);
+
+            _TurnMarker = new GaugeNeedle("{AH-64D}/Images/SAI/adi_turn_marker.xaml", new Point(178d, 315d), new Size(12d, 9d), new Point(7d, 0d));
+            Components.Add(_TurnMarker);
+
+            Components.Add(new GaugeImage("{AH-64D}/Images/SAI/adi_guides.xaml", new Rect(66d, 54d, 222d, 250d)));
+
+            _offFlagImage = new GaugeImage("{AH-64D}/Images/SAI/adi_off_flag.png", new Rect(270d, 40d, 44d, 166d));
+            _offFlagImage.IsHidden = true;
+            Components.Add(_offFlagImage);
+
+            Components.Add(new GaugeImage("{AH-64D}/Images/SAI/adi_outer_ring.xaml", new Rect(10d, 9d, 336d, 336d)));
+
+            Components.Add(new GaugeImage("{AH-64D}/Images/SAI/adi_bezel.png", new Rect(0d, 0d, 350d, 350d)));
+
+            _slipBall = new HeliosValue(this, new BindingValue(0d), "Standby Attitude Indicator", "Slip Ball Offset", "Side slip indicator offset from the center of the tube.", "(-1 to 1) -1 full left and 1 is full right.", BindingValueUnits.Numeric);
+            _slipBall.Execute += new HeliosActionHandler(SlipBall_Execute);
+            Actions.Add(_slipBall);
+
+            _turnIndicator = new HeliosValue(this, new BindingValue(0d), "Standby Attitude Indicator", "Turn Indicator Offset", "Turn indicator offset from the center of the gauge.", "(-1 to 1) -1 full left and 1 is full right.", BindingValueUnits.Numeric);
+            _turnIndicator.Execute += new HeliosActionHandler(turnIndicator_Execute);
+            Actions.Add(_turnIndicator);
+
+            _offFlag = new HeliosValue(this, new BindingValue(false), "Standby Attitude Indicator", "Off Flag", "Indicates whether the off flag is displayed.", "True if displayed.", BindingValueUnits.Boolean);
+            _offFlag.Execute += new HeliosActionHandler(OffFlag_Execute);
+            Actions.Add(_offFlag);
+
+            _pitch = new HeliosValue(this, new BindingValue(0d), "Standby Attitude Indicator", "Pitch", "Current ptich of the aircraft.", "(0 - 360)", BindingValueUnits.Degrees);
+            _pitch.Execute += new HeliosActionHandler(Pitch_Execute);
+            Actions.Add(_pitch);
+
+            _pitchAdjustment = new HeliosValue(this, new BindingValue(0d), "Standby Attitude Indicator", "SAI Pitch adjustment offset", "Location of pitch reference wings.", "(-1 to 1) 1 full up and -1 is full down.", BindingValueUnits.Numeric);
+            _pitchAdjustment.Execute += new HeliosActionHandler(PitchAdjust_Execute);
+            Actions.Add(_pitchAdjustment);
+
+            _roll = new HeliosValue(this, new BindingValue(0d), "Standby Attitude Indicator", "Bank", "Current bank of the aircraft.", "(0 - 360)", BindingValueUnits.Degrees);
+            _roll.Execute += new HeliosActionHandler(Bank_Execute);
+            Actions.Add(_roll);
+        }
+
+
+        void SlipBall_Execute(object action, HeliosActionEventArgs e)
+        {
+            _slipBall.SetValue(e.Value, e.BypassCascadingTriggers);
+            _slipBallNeedle.HorizontalOffset = _slipBallCalibration.Interpolate(e.Value.DoubleValue);
+        }
+
+        void OffFlag_Execute(object action, HeliosActionEventArgs e)
+        {
+            _offFlag.SetValue(e.Value, e.BypassCascadingTriggers);
+            _offFlagImage.IsHidden = !e.Value.BoolValue;
+        }
+
+        void Pitch_Execute(object action, HeliosActionEventArgs e)
+        {
+            _pitch.SetValue(e.Value, e.BypassCascadingTriggers);
+            _ball.VerticalOffset = _pitchCalibration.Interpolate(e.Value.DoubleValue);
+        }
+        void PitchAdjust_Execute(object action, HeliosActionEventArgs e)
+        {
+            _pitchAdjustment.SetValue(e.Value, e.BypassCascadingTriggers);
+            _wingsNeedle.VerticalOffset = -_pitchAdjustCalibaration.Interpolate(e.Value.DoubleValue);
+        }
+        void Bank_Execute(object action, HeliosActionEventArgs e)
+        {
+            _roll.SetValue(e.Value, e.BypassCascadingTriggers);
+            _ball.Rotation = -e.Value.DoubleValue;
+            _bankNeedle.Rotation = -e.Value.DoubleValue;
+        }
+        void turnIndicator_Execute(object action, HeliosActionEventArgs e)
+        {
+            _turnIndicator.SetValue(e.Value, e.BypassCascadingTriggers);
+            _TurnMarker.HorizontalOffset = _slipBallCalibration.Interpolate(e.Value.DoubleValue);
+        }
+
+    }
+}