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

using UnityEngine;

namespace Exsample
{
    public static partial class Extensions  //※クラス名は任意
    {
        /// <summary>
        /// LDR Color と intensity → HDR Color に変換する
        /// https://answers.unity.com/questions/1652854/how-to-get-set-hdr-color-intensity.html
        /// </summary>
        /// <param name="ldrColor">LDR Color</param>
        /// <param name="intensity">輝度(intensity)</param>
        /// <returns>HDR Color</returns>
        public static Color ToHDRColor(this Color ldrColor, float intensity)
        {
            var factor = Mathf.Pow(2, intensity);
            return new Color(
                ldrColor.r * factor,
                ldrColor.g * factor,
                ldrColor.b * factor,
                ldrColor.a
            );
        }
    }
}

using UnityEngine;

namespace Exsample
{
    public static partial class Extensions  //※クラス名は任意
    {
        private const byte k_MaxByteForOverexposedColor = 191;  //internal Unity const

        /// <summary>
        /// HDR Color を baseColor, intensity(exposure) に分離する (Tuple)
        /// https://answers.unity.com/questions/1652854/how-to-get-set-hdr-color-intensity.html
        /// ※overExposed = 255 を与えると直感的になる : (白) baseColor = RGBA(1.000, 1.000, 1.000, 1.000), intensity = 1
        ///   Unity デフォ = 191 で HDR Color ピッカーと同等 : (白) baseColor = RGBA(0.749, 0.749, 0.749, 1.000), intensity = 1.416925
        /// </summary>
        /// <param name="linearColorHdr">HDR Color</param>
        /// <param name="overExposed">internal Unity const = 191 (デフォルト: 255)</param>
        /// <returns>(LDR Color, intensity)</returns>
        public static (Color32, float) DecomposeHdrColor2(this Color linearColorHdr, byte overExposed = 255)
        {
            Color32 baseLinearColor32 = linearColorHdr;  //※暗黙変換には型が必要
            var exposure = 0f;

            var maxColorComponent = linearColorHdr.maxColorComponent; //※たぶん (r,g,b) 内で一番高い値 → 1f を超えてたら HDR となる

            // replicate Photoshops's decomposition behaviour : Photoshopの分解動作を複製する
            if (maxColorComponent == 0f || maxColorComponent <= 1f && maxColorComponent >= 1 / 255f) //1/255 = 0.003921568627451
            {
                exposure = 0f;
                baseLinearColor32.r = (byte)Mathf.RoundToInt(linearColorHdr.r * 255f);
                baseLinearColor32.g = (byte)Mathf.RoundToInt(linearColorHdr.g * 255f);
                baseLinearColor32.b = (byte)Mathf.RoundToInt(linearColorHdr.b * 255f);
            }
            else
            {
                // calibrate exposure to the max float color component : 最大フロートカラーコンポーネントへの露出を調整します
                var scaleFactor = overExposed / maxColorComponent;
                exposure = Mathf.Log(255f / scaleFactor) / Mathf.Log(2f);

                // maintain maximal integrity of byte values to prevent off-by-one errors when scaling up a color one component at a time
                baseLinearColor32.r = Math.Min(overExposed, (byte)Mathf.CeilToInt(scaleFactor * linearColorHdr.r));
                baseLinearColor32.g = Math.Min(overExposed, (byte)Mathf.CeilToInt(scaleFactor * linearColorHdr.g));
                baseLinearColor32.b = Math.Min(overExposed, (byte)Mathf.CeilToInt(scaleFactor * linearColorHdr.b));
            }

            return (baseLinearColor32, exposure);
        }
    }
}

//メインでは…
//var (baseColor32, intensity) = emissionColor.DecomposeHdrColor2();  //overExposed = 255

using UnityEngine;

namespace Exsample
{
    public static partial class Extensions  //※クラス名は任意
    {
        private const byte k_MaxByteForOverexposedColor = 191;  //internal Unity const

        /// <summary>
        /// HDR Color から Intensity のみを取得する
        /// https://answers.unity.com/questions/1652854/how-to-get-set-hdr-color-intensity.html
        /// ※overExposed = 255 を与えると直感的になる : (白) baseColor = RGBA(1.000, 1.000, 1.000, 1.000), intensity = 1
        ///   Unity デフォ = 191 で HDR Color ピッカーと同等 : (白) baseColor = RGBA(0.749, 0.749, 0.749, 1.000), intensity = 1.416925
        /// </summary>
        /// <param name="hdrColor">HDR Color</param>
        /// <param name="overExposed">internal Unity const = 191</param>
        /// <returns>輝度(intensity)</returns>
        public static float ExtractIntensity(this Color hdrColor, byte overExposed = 255)
        {
            var maxColorComponent = hdrColor.maxColorComponent;
            var scaleFactor = overExposed / maxColorComponent;
            return Mathf.Log(255f / scaleFactor) / Mathf.Log(2f); 
        }
    }
}

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);
}

Bitmap image1, image2;
try {
    image1 = BitmapFactory.decodeResource(getResources(), drawableID);
    image2 = image1.copy(image1.getConfig(), isMutable);    //getConfig() = null になることがある
} catch (Exception e) {
    image2 = image1.copy(Config.ARGB_8888, isMutable);    //こっちなら大丈夫
}