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

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 System;
using System.Collections.Generic;

public static class Extensions  //名前は任意
{
    /// <summary>
    /// コレクションが null または Count = 0 か？
    /// 2021/07/11 Fantom
    /// http://fantom1x.blog130.fc2.com/blog-entry-399.html
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="collection">調べるコレクション</param>
    /// <returns>true : null または Count = 0</returns>
    public static bool IsNullOrEmpty<T>(this ICollection<T> collection)
    {
        return collection == null || collection.Count == 0;
    }

    /// <summary>
    /// 配列が null または Length = 0 か？
    /// 2021/07/11 Fantom
    /// http://fantom1x.blog130.fc2.com/blog-entry-399.html
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="array">調べる配列</param>
    /// <returns>true : null または Length = 0</returns>
    public static bool IsNullOrEmpty<T>(this T[] array)
    {
        return (array == null || array.Length == 0);
    }
}

using System;
using System.Collections.Generic;

var emptyList = new List();
var list = new List() { 1, 2, 3 };
Console.WriteLine("emptyList : " + emptyList.IsNullOrEmpty());
Console.WriteLine("list : " + list.IsNullOrEmpty());

var emptyDic = new Dictionary();
var dic = new Dictionary()
{
    { "hoge", 100 },
    { "fuga", 200 },
};
Console.WriteLine("emptyDic : " + emptyDic.IsNullOrEmpty());
Console.WriteLine("dic : " + dic.IsNullOrEmpty());

var emptySet = new HashSet();
var set = new HashSet() { "hoge", "fuga" };
Console.WriteLine("emptySet : " + emptySet.IsNullOrEmpty());
Console.WriteLine("set : " + set.IsNullOrEmpty());

var emptyArray = new string[0];
var array = new string[] { "apple", "banana", "candy" };
Console.WriteLine("emptyArray : " + emptyArray.IsNullOrEmpty());
Console.WriteLine("array : " + array.IsNullOrEmpty());

//null でない、かつ Count > 0
public static bool IsExist(this ICollection collection) => !collection.IsNullOrEmpty();

//null でない、かつ Length > 0
public static bool IsExist(this T[] array) => !array.IsNullOrEmpty();

using System;
using System.Collections.Generic;

public static class Extensions  //名前は任意
{
    /// <summary>
    /// 複数の要素を追加する（同じ値は上書きとなる）
    /// ※null であっても、必ず生成される
    /// 2021/06/13 Fantom
    /// http://fantom1x.blog130.fc2.com/blog-entry-398.html
    /// </summary>
    /// <param name="set">追加先</param>
    /// <param name="collection">追加ソース</param>
    /// <returns></returns>
    public static HashSet<T> AddRange<T>(this HashSet<T> set, IEnumerable<T> collection)
    {
        if (set == null)
            set = new HashSet<T>();

        if (collection != null)
        {
            foreach (var item in collection)
                set.Add(item);
        }
        return set;
    }

    /// <summary>
    /// 複数のキーと値ペアを追加する（同じキーは上書きとなる）
    /// ※null であっても、必ず生成される.
    /// 2021/06/13 Fantom
    /// http://fantom1x.blog130.fc2.com/blog-entry-398.html
    /// </summary>
    /// <param name="dst">追加先</param>
    /// <param name="src">追加ソース</param>
    /// <returns></returns>
    public static Dictionary<K, V> AddRange<K, V>(this Dictionary<K, V> dst, Dictionary<K, V> src)
    {
        if (dst == null)
            dst = new Dictionary<K, V>();

        if (src != null)
        {
            foreach (var item in src)
                dst[item.Key] = item.Value;
        }
        return dst;
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

var aSet = new HashSet<int>(Enumerable.Range(0, 5));
Console.WriteLine("Before : " + aSet.Dump());

var bSet = new HashSet<int>(Enumerable.Range(10, 5));
aSet.AddRange(bSet);
Console.WriteLine("After : " + aSet.Dump());

var cSet = new HashSet<int>(aSet).AddRange(bSet);
Console.WriteLine("c = a + b : " + cSet.Dump());

var aDic = new Dictionary<int, string>()
{
    { 0, "a" },
    { 1, "b" },
    { 2, "c" },
};
Console.WriteLine("Before : " + aDic.Dump());

var bDic = new Dictionary<int, string>()
{
    { 10, "x" },
    { 11, "y" },
    { 12, "z" },
};
aDic.AddRange(bDic);
Console.WriteLine("After : " + aDic.Dump());

var cDic = new Dictionary<int, string>(aDic).AddRange(bDic);
Console.WriteLine("c = a + b : " + cDic.Dump());

using System;
using System.Collections.Generic;

public static class Extensions  //名前は任意
{
    /// <summary>
    /// 配列 の TryGetValue
    /// ・配列自体が null or インデクスが範囲外のとき false
    /// 2021/05/17 Fantom
    /// http://fantom1x.blog130.fc2.com/blog-entry-397.html
    /// </summary>
    /// <typeparam name="T">要素の型</typeparam>
    /// <param name="array">対象の配列</param>
    /// <param name="idx">取得するインデクス</param>
    /// <param name="value">取得成功したときの値</param>
    /// <returns>true = 取得成功</returns>
    public static bool TryGetValue<T>(this T[] array, int idx, out T value)
    {
        value = default(T);
        if (array == null || idx < 0 || array.Length <= idx)
            return false;

        value = array[idx];
        return true;
    }

    /// <summary>
    /// List の TryGetValue
    /// ・List 自体が null or インデクスが範囲外のとき false
    /// 2021/05/17 Fantom
    /// http://fantom1x.blog130.fc2.com/blog-entry-397.html
    /// </summary>
    /// <typeparam name="T">要素の型</typeparam>
    /// <param name="list">対象の List</param>
    /// <param name="idx">取得するインデクス</param>
    /// <param name="value">取得成功したときの値</param>
    /// <returns>true = 取得成功</returns>
    public static bool TryGetValue<T>(this List<T> list, int idx, out T value)
    {
        value = default(T);
        if (list == null || idx < 0 || list.Count <= idx)
            return false;

        value = list[idx];
        return true;
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

int max = 50;
var array = Enumerable.Range(0, max).ToArray();  //0～49 まで
var list = Enumerable.Range(0, max).ToList();    //0～49 まで

int idxA = 25;
if (array.TryGetValue(idxA, out var resultA))
{
    Console.WriteLine($"result value (Array) = {resultA}");
}
else
{
    Console.WriteLine($"idx = {idxA} : Index was out of range or null (Array)");
}

int idxL = 50;
if (list.TryGetValue(idxL, out var resultL))
{
    Console.WriteLine($"result value (List) = {resultL}");
}
else
{
    Console.WriteLine($"idx = {idxL} : Index was out of range or null (List)");
}

//var res = list[100];  //Index was out of range

int[] arr = {0,1,2,3,4};
int GetOrFallback(int idx) => arr.TryGetValue(idx, out var res) ? res : 0;

if (dic.ContainsKey(key))  //dic は Dictionary とする
{
    var res = dic[key];
    //ここで res を使った処理
}

if (dic.TryGetValue(key, out var res))  //dic は Dictionary とする
{
    //ここで res を使った処理
}