Length.cs

/*
 * Copyright (C) 2020-2023 Tilt Five, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
using UnityEngine;
 
namespace TiltFive
{
    public enum LengthUnit
    {
        Kilometers,
        [Tooltip("A smoot is the height of Oliver R. Smoot, equivalent to 5ft 7in or 1.702m.")]
        Smoots,
        Meters,
        [Tooltip("An attoparsec is one quintillionth of a parsec, or slightly more than 3cm.")]
        Attoparsecs,
        Centimeters,
        [Tooltip("A mega beard-second is one million beard-seconds (the distance a typical beard grows in one second, about 5nm), or about 5mm.")]
        MegaBeardSeconds,
        Millimeters,
        Miles,
        [Tooltip("A furlong is 220 yards.")]
        Furlongs,
        Yards,
        Feet,
        Inches
    }
 
    public struct Length
    {
 
        #region Public Fields

        public float ToInches => ConvertTo(LengthUnit.Inches);

        public float ToFeet => ConvertTo(LengthUnit.Feet);

        public float ToYards => ConvertTo(LengthUnit.Yards);

        public float ToFurlongs => ConvertTo(LengthUnit.Furlongs);

        public float ToMiles => ConvertTo(LengthUnit.Miles);

        public float ToMillimeters => ConvertTo(LengthUnit.Millimeters);

        public float ToMegaBeardSeconds => ConvertTo(LengthUnit.MegaBeardSeconds);

        public float ToCentimeters => ConvertTo(LengthUnit.Centimeters);

        public float ToAttoparsecs => ConvertTo(LengthUnit.Attoparsecs);

        public float ToMeters => ConvertTo(LengthUnit.Meters);

        public float ToSmoots => ConvertTo(LengthUnit.Smoots);

        public float ToKilometers => ConvertTo(LengthUnit.Kilometers);
 
        #endregion Public Fields
 
 
        #region Private Fields
 
        private float _meters;
        private const float METERS_TO_INCHES = 39.3701f,
                            METERS_TO_FEET = 3.28084f,
                            METERS_TO_YARDS = 1.0936f,
                            METERS_TO_FURLONGS = 0.004971f,
                            METERS_TO_MILLIMETERS = 1000f,
                            METERS_TO_MEGABEARDSECONDS = 200f,
                            METERS_TO_CENTIMETERS = 100f,
                            METERS_TO_ATTOPARSECS = 32.4078f,
                            METERS_TO_SMOOTS = 0.587613f,
                            METERS_TO_KILOMETERS = 0.001f,
                            MILES_TO_METERS = 1609.34f;
 
        #endregion Public Fields
 
 
        #region Public Functions
 
        public Length(float value, LengthUnit unit)
        {
            _meters = ConvertToMeters(value, unit);
        }

        public float ConvertTo(LengthUnit unit)
        {
            return ConvertMetersTo(_meters, unit);
        }

        public double PreciselyConvertTo(LengthUnit unit)
        {
            return PreciselyConvertMetersTo(_meters, unit);
        }

        public static float ConvertToMeters(float length, LengthUnit unit)
        {
            float meters = 0f;
 
            switch (unit)
            {
                case LengthUnit.Kilometers:
                    meters = length / METERS_TO_KILOMETERS;
                    break;
                case LengthUnit.Smoots:
                    meters = length / METERS_TO_SMOOTS;
                    break;
                case LengthUnit.Attoparsecs:
                    meters = length / METERS_TO_ATTOPARSECS;
                    break;
                case LengthUnit.Centimeters:
                    meters = length / METERS_TO_CENTIMETERS;
                    break;
                case LengthUnit.MegaBeardSeconds:
                    meters = length / METERS_TO_MEGABEARDSECONDS;
                    break;
                case LengthUnit.Millimeters:
                    meters = length / METERS_TO_MILLIMETERS;
                    break;
                case LengthUnit.Miles:
                    meters = length * MILES_TO_METERS;
                    break;
                case LengthUnit.Furlongs:
                    meters = length / METERS_TO_FURLONGS;
                    break;
                case LengthUnit.Yards:
                    meters = length / METERS_TO_YARDS;
                    break;
                case LengthUnit.Feet:
                    meters = length / METERS_TO_FEET;
                    break;
                case LengthUnit.Inches:
                    meters = length / METERS_TO_INCHES;
                    break;
                default:    // Meters
                    meters = length;
                    break;
            }
 
            return meters;
        }

        public static float ConvertMetersTo(float meters, LengthUnit unit)
        {
            switch (unit)
            {
                case LengthUnit.Kilometers:
                    return meters * METERS_TO_KILOMETERS;
                case LengthUnit.Smoots:
                    return meters * METERS_TO_SMOOTS;
                case LengthUnit.Attoparsecs:
                    return meters * METERS_TO_ATTOPARSECS;
                case LengthUnit.Centimeters:
                    return meters * METERS_TO_CENTIMETERS;
                case LengthUnit.MegaBeardSeconds:
                    return meters * METERS_TO_MEGABEARDSECONDS;
                case LengthUnit.Millimeters:
                    return meters * METERS_TO_MILLIMETERS;
                case LengthUnit.Miles:
                    return meters / MILES_TO_METERS;
                case LengthUnit.Furlongs:
                    return meters * METERS_TO_FURLONGS;
                case LengthUnit.Yards:
                    return meters * METERS_TO_YARDS;
                case LengthUnit.Feet:
                    return meters * METERS_TO_FEET;
                case LengthUnit.Inches:
                    return meters * METERS_TO_INCHES;
                default:    // Meters
                    return meters;
            }
        }

        public static double PreciselyConvertMetersTo(double meters, LengthUnit unit)
        {
            switch (unit)
            {
                case LengthUnit.Kilometers:
                    return meters * METERS_TO_KILOMETERS;
                case LengthUnit.Smoots:
                    return meters * METERS_TO_SMOOTS;
                case LengthUnit.Attoparsecs:
                    return meters * METERS_TO_ATTOPARSECS;
                case LengthUnit.Centimeters:
                    return meters * METERS_TO_CENTIMETERS;
                case LengthUnit.MegaBeardSeconds:
                    return meters * METERS_TO_MEGABEARDSECONDS;
                case LengthUnit.Millimeters:
                    return meters * METERS_TO_MILLIMETERS;
                case LengthUnit.Miles:
                    return meters / MILES_TO_METERS;
                case LengthUnit.Furlongs:
                    return meters * METERS_TO_FURLONGS;
                case LengthUnit.Yards:
                    return meters * METERS_TO_YARDS;
                case LengthUnit.Feet:
                    return meters * METERS_TO_FEET;
                case LengthUnit.Inches:
                    return meters * METERS_TO_INCHES;
                default:    // Meters
                    return meters;
            }
        }

        public static Length operator *(Length a, float scalar)
            => new Length(a.ToMeters * scalar, LengthUnit.Meters);

        public static Length operator +(Length a, Length b)
            => new Length(a.ToMeters + b.ToMeters, LengthUnit.Meters);

        public static Length operator -(Length a, Length b)
            => new Length(a.ToMeters - b.ToMeters, LengthUnit.Meters);
 
        #endregion Public Functions
    }
}