ヽ｜∵｜ゝ(Fantom) の 開発blog？

using UnityEngine;

namespace Exsample
{
    public static partial class Extensions  //※クラス名は任意
    {
        //無音とみなすデジベル(dB) や音量
        const float DECIBEL_MIN = -80f;  //この dB 以下をミュート(音無し)とする
        const float DECIBEL_MUTE = DECIBEL_MIN * 10;  //単位: dB (-80dB だと僅かに聞こえる気がするので、とりあえず10倍してる)
        const float VOLUME_MIN = 0.0001f;  //この volume 以下をミュート(音無し)とする

        /// <summary>
        /// 音量(0～1f) → デシベル(-80(-800)～0dB) に変換
        /// ※ただし、volume ≤ 0.0001f のとき -800 [db] を返す 
        /// (参考) https://techblog.kayac.com/linear-vs-decibel
        /// </summary>
        /// <param name="volume">0～1f</param>
        /// <returns>-80(-800)～0 [dB]</returns>
        public static float ToDecibel(this float volume)
        {
            if (volume <= VOLUME_MIN)  //0.0001f を最小値とする
                return DECIBEL_MUTE;  //-800dB (-80dB だと僅かに聞こえる気がするので、とりあえず10倍してる)
            
            var db = 20 * Mathf.Log10(volume);
            return Mathf.Clamp(db, DECIBEL_MUTE, 0f);
        }
    }
}

//音量(0～100%) → デシベル(-80(-800)～0dB) に変換
public static float PercentToDecibel(this float per) => ToDecibel(per * 0.01f);

using UnityEngine;

namespace Exsample
{
    public static partial class Extensions  //※クラス名は任意
    {
        /// <summary>
        /// デシベル(-80～0dB) → 音量(0～1f) に変換
        /// (参考) https://techblog.kayac.com/linear-vs-decibel
        /// </summary>
        /// <param name="decibel">-80～0dB</param>
        /// <returns>0～1f</returns>
        public static float FromDecibel(this float decibel)
        {
            if (decibel <= DECIBEL_MIN)  //-80dB を最小値とする
                return 0f;

            return Mathf.Pow(10f, decibel / 20f);
        }
    }
}

var volMin = 0f;
var volMax = 1f;
var volOverMin = -1f;
var volOverMax = 2f;

//volume (0～1f) → dB (-80(-800)～0dB) 変換
var dBMin = volMin.ToDecibel();
var dBMax = volMax.ToDecibel();
var dBOverMin = volOverMin.ToDecibel();
var dBOverMax = volOverMax.ToDecibel();

Debug.Log($"volMin = {volMin}, ToDecibel = {dBMin}");
Debug.Log($"volMax = {volMax}, ToDecibel = {dBMax}");
Debug.Log($"volOverMin = {volOverMin}, ToDecibel = {dBOverMin}");
Debug.Log($"volOverMax = {volOverMax}, ToDecibel = {dBOverMax}");

//dB (-80(-800)～0dB) → volume (0～1f) 変換
var dBMinToVol = dBMin.FromDecibel();
var dBMaxToVol = dBMax.FromDecibel();
var dBOverMinToVol = dBOverMin.FromDecibel();
var dBOverMaxToVol = dBOverMax.FromDecibel();

Debug.Log($"dBMin FromDecibel = {dBMinToVol}");
Debug.Log($"dBMax FromDecibel = {dBMaxToVol}");
Debug.Log($"dBOverMin FromDecibel = {dBOverMinToVol}");
Debug.Log($"dBOverMax FromDecibel = {dBOverMaxToVol}");

using UnityEngine;

//ガンマ→リニア
var gammaColor = new Color(0.3f, 0.4f, 0.5f);
var linearColor = gammaColor.linear;  //→ RGBA(0.073, 0.133, 0.214, 1.000)

var linearValue = Mathf.GammaToLinearSpace(0.5f); //→ 0.2140411ff

//リニア→ガンマ
var linearColor = new Color(0.073f, 0.133f, 0.214f);
var gammaColor = linearColor.gamma;  //→ RGBA(0.300, 0.400, 0.500, 1.000)

var gammaValue = Mathf.LinearToGammaSpace(0.2140411f); //→ 0.5f

using UnityEngine;

/// <summary>
/// ガンマ(sRGB)→リニア (0.0-1.0：正規化した値) 色空間変換 (厳密なコード)
/// (参考)
/// https://en.wikipedia.org/wiki/SRGB
/// https://tech.cygames.co.jp/archives/2339/
/// </summary>
/// <param name="gamma">0.0-1.0</param>
/// <returns>0.0-1.0</returns>
public static float ToLinearValueStrict(this float gamma)
{
    if (gamma <= 0.04045f) 
    {
        return gamma / 12.92f;
    }
    else 
    {
        return Mathf.Pow((gamma + 0.055f) / 1.055f, 2.4f);
    }
}

/// <summary>
/// リニア→ガンマ(sRGB) (0.0-1.0：正規化した値) 色空間変換 (厳密なコード)
/// (参考)
/// https://en.wikipedia.org/wiki/SRGB
/// https://tech.cygames.co.jp/archives/2339/
/// </summary>
/// <param name="linear">0.0-1.0</param>
/// <returns>0.0-1.0</returns>
public static float ToGammaValueStrict(this float linear)
{
    if (linear <= 0.0031308f)
    {
        return linear * 12.92f;
    }
    else 
    {
        return 1.055f * Mathf.Pow(linear, 0.4166666f) - 0.055f;  //0.4166666f = 1/2.4
    }
}

using UnityEngine;

/// <summary>
/// ガンマ(sRGB)→リニア (0.0-1.0：正規化した値) 色空間変換 (高速化近似式: 2.2乗)
/// (参考) https://tech.cygames.co.jp/archives/2339/
/// </summary>
/// <param name="gamma">0.0-1.0</param>
/// <returns>0.0-1.0</returns>
public static float ToLinearValueFast(this float gamma)
{
    return Mathf.Pow(gamma, 2.2f);  //or 2.233333f
}

/// <summary>
/// リニア→ガンマ(sRGB) (0.0-1.0：正規化した値) 色空間変換 (高速化近似式: 1/2.2乗)
/// (参考) https://tech.cygames.co.jp/archives/2339/
/// </summary>
/// <param name="linear">0.0-1.0</param>
/// <returns>0.0-1.0</returns>
public static float ToGammaValueFast(this float linear)
{
    return Mathf.Pow(linear, 0.45454545f);  //1/2.2
}

using UnityEngine;

/// <summary>
/// ガンマ(sRGB)→リニア (0.0-1.0：正規化した値) 色空間変換 (高速化近似式: シンプルな3次)
/// (参考) http://chilliant.blogspot.com.au/2012/08/srgb-approximations-for-hlsl.html?m=1
/// </summary>
/// <param name="gamma">0.0-1.0</param>
/// <returns>0.0-1.0</returns>
public static float ToLinearValueFastCubic(this float gamma)
{
    return gamma * (gamma * (gamma * 0.305306011f + 0.682171111f) + 0.012522878f);
}

// sRGB transfer functions
// Fast path ref: http://chilliant.blogspot.com.au/2012/08/srgb-approximations-for-hlsl.html?m=1
//
half SRGBToLinear(half c)
{
#if USE_VERY_FAST_SRGB
    return c * c;
#elif USE_FAST_SRGB
    return c * (c * (c * 0.305306011 + 0.682171111) + 0.012522878);
#else
    half linearRGBLo = c / 12.92;
    half linearRGBHi = PositivePow((c + 0.055) / 1.055, 2.4);
    half linearRGB = (c <= 0.04045) ? linearRGBLo : linearRGBHi;
    return linearRGB;
#endif
}

half3 SRGBToLinear(half3 c)
{
#if USE_VERY_FAST_SRGB
    return c * c;
#elif USE_FAST_SRGB
    return c * (c * (c * 0.305306011 + 0.682171111) + 0.012522878);
#else
    half3 linearRGBLo = c / 12.92;
    half3 linearRGBHi = PositivePow((c + 0.055) / 1.055, half3(2.4, 2.4, 2.4));
    half3 linearRGB = (c <= 0.04045) ? linearRGBLo : linearRGBHi;
    return linearRGB;
#endif
}

half4 SRGBToLinear(half4 c)
{
    return half4(SRGBToLinear(c.rgb), c.a);
}

half LinearToSRGB(half c)
{
#if USE_VERY_FAST_SRGB
    return sqrt(c);
#elif USE_FAST_SRGB
    return max(1.055 * PositivePow(c, 0.416666667) - 0.055, 0.0);
#else
    half sRGBLo = c * 12.92;
    half sRGBHi = (PositivePow(c, 1.0 / 2.4) * 1.055) - 0.055;
    half sRGB = (c <= 0.0031308) ? sRGBLo : sRGBHi;
    return sRGB;
#endif
}

half3 LinearToSRGB(half3 c)
{
#if USE_VERY_FAST_SRGB
    return sqrt(c);
#elif USE_FAST_SRGB
    return max(1.055 * PositivePow(c, 0.416666667) - 0.055, 0.0);
#else
    half3 sRGBLo = c * 12.92;
    half3 sRGBHi = (PositivePow(c, half3(1.0 / 2.4, 1.0 / 2.4, 1.0 / 2.4)) * 1.055) - 0.055;
    half3 sRGB = (c <= 0.0031308) ? sRGBLo : sRGBHi;
    return sRGB;
#endif
}

half4 LinearToSRGB(half4 c)
{
    return half4(LinearToSRGB(c.rgb), c.a);
}

#define FLT_EPSILON     1.192092896e-07

// Using pow often result to a warning like this
// "pow(f, e) will not work for negative f, use abs(f) or conditionally handle negative values if you expect them"
// PositivePow remove this warning when you know the value is positive and avoid inf/NAN.
float PositivePow(float base, float power)
{
    return pow(max(abs(base), float(FLT_EPSILON)), power);
}

float2 PositivePow(float2 base, float2 power)
{
    return pow(max(abs(base), float2(FLT_EPSILON, FLT_EPSILON)), power);
}

float3 PositivePow(float3 base, float3 power)
{
    return pow(max(abs(base), float3(FLT_EPSILON, FLT_EPSILON, FLT_EPSILON)), power);
}

float4 PositivePow(float4 base, float4 power)
{
    return pow(max(abs(base), float4(FLT_EPSILON, FLT_EPSILON, FLT_EPSILON, FLT_EPSILON)), power);
}

using System;
using System.Globalization;

public static class Extensions  //名前は任意
{
    /// <summary>
    /// 文字列 → float 変換 (CultureInfo.InvariantCulture 指定)
    /// </summary>
    /// <param name="s">変換元文字列</param>
    /// <returns>変換後の float (失敗は 0)</returns>
    public static float ToFloat(this string s)
    {
        if (float.TryParse(s, NumberStyles.Number, CultureInfo.InvariantCulture, out var value))
        {
            return value;
        }
        return 0f;
    }


    /// <summary>
    /// 文字列 → float 変換 (CultureInfo.InvariantCulture 指定)
    /// </summary>
    /// <param name="s">変換元文字列</param>
    /// <param name="result">変換成功時 = float 値 / 変換失敗時 = 0</param>
    /// <returns>true = 変換成功 / false = 変換失敗</returns>
    public static bool TryParseFloat(this string s, out float result)
    {
        if (float.TryParse(s, NumberStyles.Number, CultureInfo.InvariantCulture, out var value))
        {
            result = value;
            return true;
        }
        result = 0;
        return false;
    }
}

using System;

var s = "1.234";
Console.WriteLine("ToFloat : " + s.ToFloat());

if (s.TryParseFloat(out var result))
{
    Console.WriteLine("TryParseFloat : " + result);
}
else
{
    Console.WriteLine("TryParseFloat failed");
}

using UnityEngine;

public static class MathfExtentions  //※クラス名は任意
{
    /// <summary>
    /// 下限～上限(を含まない)範囲を返す Mathf.Repeat
    /// 2020/12/20 Fantom 
    /// http://fantom1x.blog130.fc2.com/blog-entry-390.html
    /// </summary>
    /// <param name="value">元の値</param>
    /// <param name="min">下限 (inclusive)</param>
    /// <param name="max">上限 (exclusive)</param>
    /// <returns>min(inclusive)～max(exclusive) の Mathf.Repeat</returns>
    public static float Repeat(this float value, float min, float max)
    {
        return Mathf.Repeat(value - min, max - min) + min;
    }

    //int 版
    public static int Repeat(this int value, int min, int max)
    {
        return (int)Mathf.Repeat(value - min, max - min) + min;
    }
}

using UnityEngine;
using System.Text;

var sb = new StringBuilder(1024);
for (int i = -45; i <= 45; i++)
{
    var x = i.Repeat(-45, 45);
    if (sb.Length > 0)
        sb.Append(", ");
    sb.Append(x);
}

Debug.Log(sb.ToString());

using UnityEngine;

public static class MathfExtentions  //※クラス名は任意
{
    /// <summary>
    /// 下限～上限(を含む)範囲を返す Mathf.Repeat
    /// 2020/12/20 Fantom 
    /// http://fantom1x.blog130.fc2.com/blog-entry-390.html
    /// </summary>
    /// <param name="value">元の値</param>
    /// <param name="min">下限 (inclusive)</param>
    /// <param name="max">上限 (inclusive)</param>
    /// <returns>min(inclusive)～max(inclusive) の Mathf.Repeat</returns>
    public static float RepeatInclusive(this float value, float min, float max)
    {
        return (value == max) ? max : Repeat(value, min, max);  //※「下限～上限(を含まない)」関数が必要
    }

    //int 版
    public static int RepeatInclusive(this int value, int min, int max)
    {
        return (value == max) ? max : Repeat(value, min, max);
    }
}

using UnityEngine;
using System.Text;

var sb = new StringBuilder(1024);
for (int i = -45; i <= 45; i++)
{
    var x = i.RepeatInclusive(-45, 45);
    if (sb.Length > 0)
        sb.Append(", ");
    sb.Append(x);
}

Debug.Log(sb.ToString());

/// <summary>
/// 最小公倍数を求める(Least Common Multiple)
/// 2020/11/14 Fantom 
/// http://fantom1x.blog130.fc2.com/blog-entry-385.html
/// http://fantom1x.blog130.fc2.com/blog-entry-384.html
/// http://fantom1x.blog130.fc2.com/blog-entry-215.html#lcm
/// </summary>
/// <param name="a">数値1 (>0)</param>
/// <param name="b">数値2 (>0)</param>
/// <returns>最小公倍数</returns>
public static int Lcm(this int a, int b)
{
    return a * b / Gcd(a, b);  //※Gcd は前回の記事を参照
}

using System;

int h = 16;
int v = 9;
int m = Lcm(h, v);
Console.WriteLine("m = " + m);