Unity Matplotlib Gradient Library

2024-07-30 14:03 UTC gpt-4o Open in ChatGPT ↗

To create a Unity gradient library file that includes gradients similar to those in Matplotlib (like Viridis, Inferno, etc.), we can follow these steps:

Get the Color Data: Extract the color data from Matplotlib’s gradients.
Create Gradient Presets in Unity: Use the extracted color data to create gradient presets in Unity.

Let’s start by getting the color data for each of the gradients. Here’s the Python script to extract color data from Matplotlib gradients and save it to a JSON file.

import json
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap

# List of Matplotlib colormaps to include
colormaps = ['viridis', 'inferno', 'plasma', 'magma', 'cividis']

# Dictionary to store the colormap data
colormap_data = {}

for cmap_name in colormaps:
    cmap = plt.get_cmap(cmap_name)
    colors = cmap(np.linspace(0, 1, 256))  # 256 samples from the colormap
    color_list = [list(color[:3]) for color in colors]  # Extract RGB values
    colormap_data[cmap_name] = color_list

# Save the colormap data to a JSON file
with open('/mnt/data/colormaps.json', 'w') as f:
    json.dump(colormap_data, f, indent=4)

After running this script, a JSON file named colormaps.json will be generated containing the RGB values for each colormap.

Next, we need to convert this data into a Unity gradient library file. Here is a script to do that:

Unity Script: A Unity script that reads the JSON file and creates gradient assets.

using UnityEngine;
using UnityEditor;
using System.IO;
using System.Collections.Generic;

public class GradientCreator : Editor
{
    [MenuItem("Tools/Create Gradients From JSON")]
    public static void CreateGradients()
    {
        string filePath = "Assets/colormaps.json";
        if (!File.Exists(filePath))
        {
            Debug.LogError("File not found: " + filePath);
            return;
        }

        string jsonData = File.ReadAllText(filePath);
        var colormapData = JsonUtility.FromJson<ColormapData>(jsonData);

        foreach (var cmap in colormapData.colormaps)
        {
            Gradient gradient = new Gradient();
            GradientColorKey[] colorKeys = new GradientColorKey[cmap.colors.Count];
            GradientAlphaKey[] alphaKeys = new GradientAlphaKey[cmap.colors.Count];

            for (int i = 0; i < cmap.colors.Count; i++)
            {
                float t = (float)i / (cmap.colors.Count - 1);
                Color color = new Color(cmap.colors[i][0], cmap.colors[i][1], cmap.colors[i][2]);
                colorKeys[i] = new GradientColorKey(color, t);
                alphaKeys[i] = new GradientAlphaKey(1.0f, t);  // Assuming full opacity
            }

            gradient.SetKeys(colorKeys, alphaKeys);

            GradientAsset asset = ScriptableObject.CreateInstance<GradientAsset>();
            asset.gradient = gradient;

            AssetDatabase.CreateAsset(asset, "Assets/Gradients/" + cmap.name + ".asset");
        }

        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();
    }

    [System.Serializable]
    private class ColormapData
    {
        public List<Colormap> colormaps;
    }

    [System.Serializable]
    private class Colormap
    {
        public string name;
        public List<List<float>> colors;
    }
}

[CreateAssetMenu(fileName = "New Gradient", menuName = "Gradient Asset", order = 51)]
public class GradientAsset : ScriptableObject
{
    public Gradient gradient;
}

Steps to use the Unity Script:

Save the colormaps.json file generated from the Python script in the Assets folder of your Unity project.
Save the Unity C# script in the Editor folder within your Unity project.
Run the script by navigating to Tools -> Create Gradients From JSON in the Unity editor.

This script will create gradient assets for each Matplotlib colormap and store them in the Assets/Gradients folder in your Unity project. Each gradient will be a ScriptableObject that you can use in your Unity materials and shaders.

To directly generate Unity gradient asset files as text files in Python, we need to format the gradient data appropriately for Unity’s Gradient object. Here is the Python script to generate Unity asset files for the gradients directly:

Generate Gradient Asset File: The following Python script will create text files for each gradient in the required format.

import json
import numpy as np
import os

# Define the directory to save the gradient assets
output_dir = '/mnt/data/UnityGradients'
os.makedirs(output_dir, exist_ok=True)

# Load the colormap data
with open('/mnt/data/colormaps.json', 'r') as f:
    colormap_data = json.load(f)

# Template for Unity Gradient ScriptableObject
gradient_template = """%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!114 &11400000
MonoBehaviour:
  m_ObjectHideFlags: 0
  m_CorrespondingSourceObject: {{fileID: 0}}
  m_PrefabInstance: {{fileID: 0}}
  m_PrefabAsset: {{fileID: 0}}
  m_GameObject: {{fileID: 0}}
  m_Enabled: 1
  m_EditorHideFlags: 0
  m_Script: {{fileID: 11500000, guid: 0000000000000000d000000000000000, type: 3}}
  m_Name: {name}
  m_EditorClassIdentifier:
  gradient:
    m_Mode: 0
    m_ColorKeys:
{color_keys}
    m_AlphaKeys:
{alpha_keys}
    m_NumColorKeys: {num_keys}
    m_NumAlphaKeys: {num_keys}
"""

# Function to format color keys
def format_color_keys(colors):
    color_keys = []
    for i, color in enumerate(colors):
        t = i / (len(colors) - 1)
        color_str = f"      - time: {t}\n        color: {{r: {color[0]}, g: {color[1]}, b: {color[2]}, a: 1}}\n"
        color_keys.append(color_str)
    return ''.join(color_keys)

# Function to format alpha keys
def format_alpha_keys(colors):
    alpha_keys = []
    for i in range(len(colors)):
        t = i / (len(colors) - 1)
        alpha_str = f"      - time: {t}\n        alpha: 1\n"
        alpha_keys.append(alpha_str)
    return ''.join(alpha_keys)

# Generate Unity gradient asset files
for cmap_name, colors in colormap_data.items():
    color_keys = format_color_keys(colors)
    alpha_keys = format_alpha_keys(colors)
    num_keys = len(colors)

    gradient_asset = gradient_template.format(
        name=cmap_name,
        color_keys=color_keys,
        alpha_keys=alpha_keys,
        num_keys=num_keys
    )

    output_file = os.path.join(output_dir, f"{cmap_name}.asset")
    with open(output_file, 'w') as f:
        f.write(gradient_asset)

print("Unity gradient assets created successfully.")

Explanation:

Gradient Template: The template defines the YAML structure of a Unity Gradient asset.
Format Color and Alpha Keys: Functions format_color_keys and format_alpha_keys are used to create properly formatted strings for the color and alpha keys sections of the gradient.
Generate Asset Files: For each colormap, the script generates a .asset file containing the gradient information.

Steps to Use:

Run the Python script. It will generate .asset files in the specified output_dir.
Copy these .asset files into the Assets folder of your Unity project.
Unity will automatically import these as ScriptableObject assets that you can use in your materials and shaders.

This approach creates gradient assets directly in Python without the need for further processing in Unity.

To combine the two scripts and ensure that Unity does not exceed the 8 keys per gradient limit, we need to adjust the sampling of the colors from the Matplotlib colormaps. Here is the complete Python script:

import json
import numpy as np
import os

# Define the directory to save the gradient assets
output_dir = '/mnt/data/UnityGradients'
os.makedirs(output_dir, exist_ok=True)

# List of Matplotlib colormaps to include
colormaps = ['viridis', 'inferno', 'plasma', 'magma', 'cividis']

# Dictionary to store the colormap data
colormap_data = {}

for cmap_name in colormaps:
    cmap = plt.get_cmap(cmap_name)
    colors = cmap(np.linspace(0, 1, 256))  # 256 samples from the colormap
    color_list = [list(color[:3]) for color in colors]  # Extract RGB values
    colormap_data[cmap_name] = color_list

# Save the colormap data to a JSON file
with open('/mnt/data/colormaps.json', 'w') as f:
    json.dump(colormap_data, f, indent=4)

# Template for Unity Gradient ScriptableObject
gradient_template = """%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!114 &11400000
MonoBehaviour:
  m_ObjectHideFlags: 0
  m_CorrespondingSourceObject: {{fileID: 0}}
  m_PrefabInstance: {{fileID: 0}}
  m_PrefabAsset: {{fileID: 0}}
  m_GameObject: {{fileID: 0}}
  m_Enabled: 1
  m_EditorHideFlags: 0
  m_Script: {{fileID: 11500000, guid: 0000000000000000d000000000000000, type: 3}}
  m_Name: {name}
  m_EditorClassIdentifier:
  gradient:
    m_Mode: 0
    m_ColorKeys:
{color_keys}
    m_AlphaKeys:
{alpha_keys}
    m_NumColorKeys: {num_keys}
    m_NumAlphaKeys: {num_keys}
"""

# Function to format color keys
def format_color_keys(colors):
    color_keys = []
    for i, color in enumerate(colors):
        t = i / (len(colors) - 1)
        color_str = f"      - time: {t}\n        color: {{r: {color[0]}, g: {color[1]}, b: {color[2]}, a: 1}}\n"
        color_keys.append(color_str)
    return ''.join(color_keys)

# Function to format alpha keys
def format_alpha_keys(colors):
    alpha_keys = []
    for i in range(len(colors)):
        t = i / (len(colors) - 1)
        alpha_str = f"      - time: {t}\n        alpha: 1\n"
        alpha_keys.append(alpha_str)
    return ''.join(alpha_keys)

# Generate Unity gradient asset files
for cmap_name, colors in colormap_data.items():
    # Reduce the number of keys to 8
    reduced_colors = [colors[i] for i in np.linspace(0, len(colors) - 1, 8, dtype=int)]

    color_keys = format_color_keys(reduced_colors)
    alpha_keys = format_alpha_keys(reduced_colors)
    num_keys = len(reduced_colors)

    gradient_asset = gradient_template.format(
        name=cmap_name,
        color_keys=color_keys,
        alpha_keys=alpha_keys,
        num_keys=num_keys
    )

    output_file = os.path.join(output_dir, f"{cmap_name}.asset")
    with open(output_file, 'w') as f:
        f.write(gradient_asset)

print("Unity gradient assets created successfully.")

Explanation:

Combining the Scripts: The script combines the previous steps of extracting color data from Matplotlib colormaps and generating Unity gradient asset files.
Sampling Colors: It samples 8 colors from each colormap to ensure that Unity’s gradient limit is not exceeded.
Generating Assets: The script generates .asset files formatted for Unity and saves them in the specified directory.

Steps to Use:

Run the Script: Execute the script in a Python environment where Matplotlib and NumPy are installed.
Copy Asset Files: Move the generated .asset files from the output_dir to the Assets folder of your Unity project.
Import in Unity: Unity will automatically import these as ScriptableObject assets ready for use in your materials and shaders.

To generate a .gradients library file directly, we can create a format that Unity can import as a library of gradient assets. Unity typically uses YAML for its asset files, so we’ll follow a similar structure but include multiple gradients in one file.

Here’s a Python script that generates a .gradients file with the necessary structure:

import json
import numpy as np
import os

# Define the directory to save the gradient assets
output_dir = '/mnt/data'
os.makedirs(output_dir, exist_ok=True)

# List of Matplotlib colormaps to include
colormaps = ['viridis', 'inferno', 'plasma', 'magma', 'cividis']

# Dictionary to store the colormap data
colormap_data = {}

for cmap_name in colormaps:
    cmap = plt.get_cmap(cmap_name)
    colors = cmap(np.linspace(0, 1, 256))  # 256 samples from the colormap
    color_list = [list(color[:3]) for color in colors]  # Extract RGB values
    colormap_data[cmap_name] = color_list

# Template for Unity Gradient ScriptableObject
gradient_template = """
- Class: Gradient
  Name: {name}
  Gradient:
    Mode: 0
    ColorKeys:
{color_keys}
    AlphaKeys:
{alpha_keys}
"""

# Function to format color keys
def format_color_keys(colors):
    color_keys = []
    for i, color in enumerate(colors):
        t = i / (len(colors) - 1)
        color_str = f"      - Time: {t}\n        Color: {{r: {color[0]}, g: {color[1]}, b: {color[2]}, a: 1}}\n"
        color_keys.append(color_str)
    return ''.join(color_keys)

# Function to format alpha keys
def format_alpha_keys(colors):
    alpha_keys = []
    for i in range(len(colors)):
        t = i / (len(colors) - 1)
        alpha_str = f"      - Time: {t}\n        Alpha: 1\n"
        alpha_keys.append(alpha_str)
    return ''.join(alpha_keys)

# Generate Unity gradient library file
gradients_library_content = "%YAML 1.1\n%TAG !u! tag:unity3d.com,2011:\n"

for cmap_name, colors in colormap_data.items():
    # Reduce the number of keys to 8
    reduced_colors = [colors[i] for i in np.linspace(0, len(colors) - 1, 8, dtype=int)]

    color_keys = format_color_keys(reduced_colors)
    alpha_keys = format_alpha_keys(reduced_colors)

    gradient_asset = gradient_template.format(
        name=cmap_name,
        color_keys=color_keys,
        alpha_keys=alpha_keys
    )

    gradients_library_content += gradient_asset

output_file = os.path.join(output_dir, "gradients_library.gradients")
with open(output_file, 'w') as f:
    f.write(gradients_library_content)

print("Unity gradients library file created successfully.")

Explanation:

Combining the Scripts: The script extracts color data from Matplotlib colormaps and formats it for Unity gradient assets.
Sampling Colors: It samples 8 colors from each colormap to ensure that Unity’s gradient limit is not exceeded.
Generating .gradients File: The script creates a .gradients file that includes multiple gradient assets in a format that Unity can recognize.

Steps to Use:

Run the Script: Execute the script in a Python environment where Matplotlib and NumPy are installed.
Copy the .gradients File: Move the generated gradients_library.gradients file to the Assets folder of your Unity project.
Import in Unity: Unity will recognize the file and import the gradients as assets, ready for use in your materials and shaders.

this is how a .gradient file looks like:

%YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!114 &1 MonoBehaviour: m_ObjectHideFlags: 52 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 0} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 12321, guid: 0000000000000000e000000000000000, type: 0} m_Name: m_EditorClassIdentifier: m_Presets:

m_Name: gradient one m_Gradient: serializedVersion: 2 key0: {r: 0.9339623, g: 0.4580064, b: 0.3039783, a: 1} key1: {r: 0.3532396, g: 0.68966514, b: 0.9245283, a: 1} key2: {r: 0, g: 0, b: 0, a: 0} key3: {r: 0, g: 0, b: 0, a: 0} key4: {r: 0, g: 0, b: 0, a: 0} key5: {r: 0, g: 0, b: 0, a: 0} key6: {r: 0, g: 0, b: 0, a: 0} key7: {r: 0, g: 0, b: 0, a: 0} ctime0: 0 ctime1: 65535 ctime2: 0 ctime3: 0 ctime4: 0 ctime5: 0 ctime6: 0 ctime7: 0 atime0: 0 atime1: 65535 atime2: 0 atime3: 0 atime4: 0 atime5: 0 atime6: 0 atime7: 0 m_Mode: 2 m_ColorSpace: -1 m_NumColorKeys: 2 m_NumAlphaKeys: 2

To generate a .gradients library file in Python that matches the format you’ve provided, we’ll adapt the script accordingly. Here’s a script that will generate a Unity-compatible .gradients file:

import json
import numpy as np
import os
import matplotlib.pyplot as plt

# Define the directory to save the gradient assets
output_dir = '/mnt/data'
os.makedirs(output_dir, exist_ok=True)

# List of Matplotlib colormaps to include
colormaps = ['viridis', 'inferno', 'plasma', 'magma', 'cividis']

# Dictionary to store the colormap data
colormap_data = {}

for cmap_name in colormaps:
    cmap = plt.get_cmap(cmap_name)
    colors = cmap(np.linspace(0, 1, 256))  # 256 samples from the colormap
    color_list = [list(color[:3]) for color in colors]  # Extract RGB values
    colormap_data[cmap_name] = color_list

# Template for Unity Gradient ScriptableObject
gradient_template = """
  - m_Name: {name}
    m_Gradient:
      serializedVersion: 2
{color_keys}
{alpha_keys}
      m_Mode: 2
      m_ColorSpace: -1
      m_NumColorKeys: {num_color_keys}
      m_NumAlphaKeys: {num_alpha_keys}
"""

# Function to format color keys
def format_color_keys(colors):
    color_keys = []
    ctimes = []
    for i, color in enumerate(colors):
        color_str = f"      key{i}: {{r: {color[0]}, g: {color[1]}, b: {color[2]}, a: 1}}\n"
        color_keys.append(color_str)
        ctimes.append(f"      ctime{i}: {int(i * 65535 / (len(colors) - 1))}\n")

    # Fill the remaining keys with default values
    for i in range(len(colors), 8):
        color_keys.append(f"      key{i}: {{r: 0, g: 0, b: 0, a: 0}}\n")
        ctimes.append(f"      ctime{i}: 0\n")

    return ''.join(color_keys) + ''.join(ctimes)

# Function to format alpha keys
def format_alpha_keys(colors):
    alpha_keys = []
    atimes = []
    for i in range(len(colors)):
        alpha_keys.append(f"      atime{i}: {int(i * 65535 / (len(colors) - 1))}\n")
        atimes.append(f"      atime{i}: {int(i * 65535 / (len(colors) - 1))}\n")

    # Fill the remaining keys with default values
    for i in range(len(colors), 8):
        alpha_keys.append(f"      atime{i}: 0\n")
        atimes.append(f"      atime{i}: 0\n")

    return ''.join(alpha_keys) + ''.join(atimes)

# Generate Unity gradient library file
gradients_library_content = """%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!114 &1
MonoBehaviour:
  m_ObjectHideFlags: 52
  m_CorrespondingSourceObject: {fileID: 0}
  m_PrefabInstance: {fileID: 0}
  m_PrefabAsset: {fileID: 0}
  m_GameObject: {fileID: 0}
  m_Enabled: 1
  m_EditorHideFlags: 0
  m_Script: {fileID: 12321, guid: 0000000000000000e000000000000000, type: 0}
  m_Name:
  m_EditorClassIdentifier:
  m_Presets:
"""

for cmap_name, colors in colormap_data.items():
    # Reduce the number of keys to 8
    reduced_colors = [colors[i] for i in np.linspace(0, len(colors) - 1, 8, dtype=int)]

    color_keys = format_color_keys(reduced_colors)
    alpha_keys = format_alpha_keys(reduced_colors)

    gradient_asset = gradient_template.format(
        name=cmap_name,
        color_keys=color_keys,
        alpha_keys=alpha_keys,
        num_color_keys=min(8, len(reduced_colors)),
        num_alpha_keys=min(8, len(reduced_colors))
    )

    gradients_library_content += gradient_asset

gradients_library_content += "  m_NumColorKeys: 2\n  m_NumAlphaKeys: 2\n"

output_file = os.path.join(output_dir, "gradients_library.gradients")
with open(output_file, 'w') as f:
    f.write(gradients_library_content)

print("Unity gradients library file created successfully.")

Explanation:

Combining the Scripts: The script extracts color data from Matplotlib colormaps and formats it for Unity gradient assets.
Sampling Colors: It samples 8 colors from each colormap to ensure that Unity’s gradient limit is not exceeded.
Formatting: The script formats the gradient data according to Unity’s YAML structure for MonoBehaviour.
Generating .gradients File: The script creates a .gradients file that includes multiple gradient assets in a format that Unity can recognize.

Steps to Use:

Run the Script: Execute the script in a Python environment where Matplotlib and NumPy are installed.
Copy the .gradients File: Move the generated gradients_library.gradients file to the Assets folder of your Unity project.
Import in Unity: Unity will recognize the file and import the gradients as assets, ready for use in your materials and shaders.

Understood. Here’s the revised script incorporating your requirements:

Use no newlines within key entries.
Don’t duplicate atime.
Use only 2 alpha keys at 0 and 65535.
Give the same name to the file and the m_Name property.

import json
import numpy as np
import os
import matplotlib.pyplot as plt

# Define the directory to save the gradient assets
output_dir = '/mnt/data'
os.makedirs(output_dir, exist_ok=True)

# List of Matplotlib colormaps to include
colormaps = ['viridis', 'inferno', 'plasma', 'magma', 'cividis']

# Dictionary to store the colormap data
colormap_data = {}

for cmap_name in colormaps:
    cmap = plt.get_cmap(cmap_name)
    colors = cmap(np.linspace(0, 1, 256))  # 256 samples from the colormap
    color_list = [list(color[:3]) for color in colors]  # Extract RGB values
    colormap_data[cmap_name] = color_list

# Template for Unity Gradient ScriptableObject
gradient_template = """
  - m_Name: {name}
    m_Gradient:
      serializedVersion: 2
{color_keys}
      atime0: 0
      atime1: 65535
      atime2: 0
      atime3: 0
      atime4: 0
      atime5: 0
      atime6: 0
      atime7: 0
      m_Mode: 2
      m_ColorSpace: -1
      m_NumColorKeys: {num_color_keys}
      m_NumAlphaKeys: 2
"""

# Function to format color keys
def format_color_keys(colors):
    color_keys = []
    ctimes = []
    for i, color in enumerate(colors):
        color_str = f"      key{i}: {{r: {color[0]}, g: {color[1]}, b: {color[2]}, a: 1}}"
        color_keys.append(color_str)
        ctimes.append(f"      ctime{i}: {int(i * 65535 / (len(colors) - 1))}")

    # Fill the remaining keys with default values
    for i in range(len(colors), 8):
        color_keys.append(f"      key{i}: {{r: 0, g: 0, b: 0, a: 0}}")
        ctimes.append(f"      ctime{i}: 0")

    return '\n'.join(color_keys + ctimes)

# Generate Unity gradient library file
gradients_library_content = """%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!114 &1
MonoBehaviour:
  m_ObjectHideFlags: 52
  m_CorrespondingSourceObject: {fileID: 0}
  m_PrefabInstance: {fileID: 0}
  m_PrefabAsset: {fileID: 0}
  m_GameObject: {fileID: 0}
  m_Enabled: 1
  m_EditorHideFlags: 0
  m_Script: {fileID: 12321, guid: 0000000000000000e000000000000000, type: 0}
  m_Name:
  m_EditorClassIdentifier:
  m_Presets:
"""

for cmap_name, colors in colormap_data.items():
    # Reduce the number of keys to 8
    reduced_colors = [colors[i] for i in np.linspace(0, len(colors) - 1, 8, dtype=int)]

    color_keys = format_color_keys(reduced_colors)

    gradient_asset = gradient_template.format(
        name=cmap_name,
        color_keys=color_keys,
        num_color_keys=min(8, len(reduced_colors))
    )

    gradients_library_content += gradient_asset

gradients_library_content += "  m_NumColorKeys: 2\n  m_NumAlphaKeys: 2\n"

output_file = os.path.join(output_dir, "gradients_library.gradients")
with open(output_file, 'w') as f:
    f.write(gradients_library_content)

print("Unity gradients library file created successfully.")

Explanation:

No Newlines in Key Entries: The script ensures that key entries are written in a single line.
Unique atime Entries: The script only uses 2 alpha keys at 0 and 65535.
Naming: The script assigns the same name to the file and the m_Name property for each gradient.
Formatting: The script formats the gradient data according to Unity’s YAML structure for MonoBehaviour.

Steps to Use:

Run the Script: Execute the script in a Python environment where Matplotlib and NumPy are installed.
Copy the .gradients File: Move the generated gradients_library.gradients file to the Assets folder of your Unity project.
Import in Unity: Unity will recognize the file and import the gradients as assets, ready for use in your materials and shaders.

Matplotlib includes a wide range of colormaps that can be used for visualizing data. Below is a list of all the colormaps available in Matplotlib as of the latest version:

Perceptually Uniform Sequential

viridis
plasma
inferno
magma
cividis

Sequential

Greys
Purples
Blues
Greens
Oranges
Reds
YlOrBr
YlOrRd
OrRd
PuRd
RdPu
BuPu
GnBu
PuBu
YlGnBu
PuBuGn
BuGn
YlGn

Sequential (2)

binary
gist_yarg
gist_gray
gray
bone
pink
spring
summer
autumn
winter
cool
Wistia
hot
afmhot
gist_heat
copper

Diverging

PiYG
PRGn
BrBG
PuOr
RdGy
RdBu
RdYlBu
RdYlGn
Spectral
coolwarm
bwr
seismic

Cyclic

twilight
twilight_shifted
hsv

Qualitative

Pastel1
Pastel2
Paired
Accent
Dark2
Set1
Set2
Set3
tab10
tab20
tab20b
tab20c

Miscellaneous

flag
prism
ocean
gist_earth
terrain
gist_stern
rainbow
jet
turbo
nipy_spectral
gist_ncar

You can also get this list programmatically using Matplotlib:

import matplotlib.pyplot as plt

colormaps = plt.colormaps()
print(colormaps)

This script will print out all available colormaps in your current Matplotlib version.

Sure, I will provide a Python script that generates two versions of the gradients: one with colors in sRGB space and the other with colors in Linear color space. The script will produce two separate .gradients files.

Here’s the complete Python script:

import json
import numpy as np
import os
import matplotlib.pyplot as plt

# Define the directory to save the gradient assets
output_dir = '/mnt/data'
os.makedirs(output_dir, exist_ok=True)

# List of Matplotlib colormaps to include
colormaps = plt.colormaps()

# Dictionary to store the colormap data
colormap_data_srgb = {}
colormap_data_linear = {}

for cmap_name in colormaps:
    cmap = plt.get_cmap(cmap_name)
    colors = cmap(np.linspace(0, 1, 256))  # 256 samples from the colormap
    srgb_colors = [list(color[:3]) for color in colors]  # Extract RGB values in sRGB space
    linear_colors = [list(plt.colors.rgb_to_hsv(color[:3])) for color in colors]  # Convert to linear RGB
    colormap_data_srgb[cmap_name] = srgb_colors
    colormap_data_linear[cmap_name] = linear_colors

# Template for Unity Gradient ScriptableObject
gradient_template = """
  - m_Name: {name}
    m_Gradient:
      serializedVersion: 2
{color_keys}
      atime0: 0
      atime1: 65535
      atime2: 0
      atime3: 0
      atime4: 0
      atime5: 0
      atime6: 0
      atime7: 0
      m_Mode: 2
      m_ColorSpace: -1
      m_NumColorKeys: {num_color_keys}
      m_NumAlphaKeys: 2
"""

# Function to format color keys
def format_color_keys(colors):
    color_keys = []
    ctimes = []
    for i, color in enumerate(colors):
        color_str = f"      key{i}: {{r: {color[0]}, g: {color[1]}, b: {color[2]}, a: 1}}"
        color_keys.append(color_str)
        ctimes.append(f"      ctime{i}: {int(i * 65535 / (len(colors) - 1))}")

    # Fill the remaining keys with default values
    for i in range(len(colors), 8):
        color_keys.append(f"      key{i}: {{r: 0, g: 0, b: 0, a: 0}}")
        ctimes.append(f"      ctime{i}: 0")

    return '\n'.join(color_keys + ctimes)

# Function to generate gradient content
def generate_gradient_content(colormap_data):
    gradients_library_content = """%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!114 &1
MonoBehaviour:
  m_ObjectHideFlags: 52
  m_CorrespondingSourceObject: {fileID: 0}
  m_PrefabInstance: {fileID: 0}
  m_PrefabAsset: {fileID: 0}
  m_GameObject: {fileID: 0}
  m_Enabled: 1
  m_EditorHideFlags: 0
  m_Script: {fileID: 12321, guid: 0000000000000000e000000000000000, type: 0}
  m_Name:
  m_EditorClassIdentifier:
  m_Presets:
"""

    for cmap_name, colors in colormap_data.items():
        # Reduce the number of keys to 8
        reduced_colors = [colors[i] for i in np.linspace(0, len(colors) - 1, 8, dtype=int)]

        color_keys = format_color_keys(reduced_colors)

        gradient_asset = gradient_template.format(
            name=cmap_name,
            color_keys=color_keys,
            num_color_keys=min(8, len(reduced_colors))
        )

        gradients_library_content += gradient_asset

    gradients_library_content += "  m_NumColorKeys: 2\n  m_NumAlphaKeys: 2\n"
    return gradients_library_content

# Generate the sRGB gradients library file
srgb_gradients_content = generate_gradient_content(colormap_data_srgb)
output_file_srgb = os.path.join(output_dir, "gradients_library_srgb.gradients")
with open(output_file_srgb, 'w') as f:
    f.write(srgb_gradients_content)

# Generate the Linear gradients library file
linear_gradients_content = generate_gradient_content(colormap_data_linear)
output_file_linear = os.path.join(output_dir, "gradients_library_linear.gradients")
with open(output_file_linear, 'w') as f:
    f.write(linear_gradients_content)

print("Unity gradients library files created successfully.")

Explanation:

Extracting Colors: The script extracts colors from each Matplotlib colormap and converts them to sRGB and Linear color spaces.
Formatting Gradient Keys: The function format_color_keys formats the color keys and times.
Generating Gradient Content: The function generate_gradient_content generates the content for the .gradients file.
Saving Files: The script saves two .gradients files, one for sRGB colors and one for Linear colors.

Steps to Use:

Run the Script: Execute the script in a Python environment where Matplotlib and NumPy are installed.
Copy the .gradients Files: Move the generated gradients_library_srgb.gradients and gradients_library_linear.gradients files to the Assets folder of your Unity project.
Import in Unity: Unity will recognize the files and import the gradients as assets, ready for use in your materials and shaders.

You are right to question the conversion method used. The rgb_to_hsv function from Matplotlib is not the appropriate function for converting sRGB to linear RGB.

To convert sRGB values to linear RGB, the correct approach involves applying a gamma correction. The typical formula for converting sRGB to linear RGB is:

$ C_{linear} = \begin{cases} \frac{C_{srgb}}{12.92} & \text{if } C_{srgb} \leq 0.04045 \ \left( \frac{C_{srgb} + 0.055}{1.055} \right)^{2.4} & \text{if } C_{srgb} > 0.04045 \end{cases} $

Here’s the corrected Python script that converts sRGB to linear RGB properly and generates two versions of the gradients file:

import json
import numpy as np
import os
import matplotlib.pyplot as plt

# Define the directory to save the gradient assets
output_dir = '/mnt/data'
os.makedirs(output_dir, exist_ok=True)

# List of Matplotlib colormaps to include
colormaps = plt.colormaps()

# Function to convert sRGB to Linear RGB
def srgb_to_linear(color):
    def convert_channel(c):
        if c <= 0.04045:
            return c / 12.92
        else:
            return ((c + 0.055) / 1.055) ** 2.4

    return [convert_channel(channel) for channel in color]

# Dictionary to store the colormap data
colormap_data_srgb = {}
colormap_data_linear = {}

for cmap_name in colormaps:
    cmap = plt.get_cmap(cmap_name)
    colors = cmap(np.linspace(0, 1, 256))  # 256 samples from the colormap
    srgb_colors = [list(color[:3]) for color in colors]  # Extract RGB values in sRGB space
    linear_colors = [srgb_to_linear(color[:3]) for color in colors]  # Convert to linear RGB
    colormap_data_srgb[cmap_name] = srgb_colors
    colormap_data_linear[cmap_name] = linear_colors

# Template for Unity Gradient ScriptableObject
gradient_template = """
  - m_Name: {name}
    m_Gradient:
      serializedVersion: 2
{color_keys}
      atime0: 0
      atime1: 65535
      atime2: 0
      atime3: 0
      atime4: 0
      atime5: 0
      atime6: 0
      atime7: 0
      m_Mode: 2
      m_ColorSpace: -1
      m_NumColorKeys:

Certainly! Here’s the function to convert sRGB colors to linear RGB:

def srgb_to_linear(color):
    def convert_channel(c):
        if c <= 0.04045:
            return c / 12.92
        else:
            return ((c + 0.055) / 1.055) ** 2.4

    return [convert_channel(channel) for channel in color]

Example Usage:

To demonstrate the conversion, here’s an example showing how to use this function to convert an sRGB color to linear RGB:

import matplotlib.pyplot as plt
import numpy as np

# Example sRGB color (as [R, G, B])
srgb_color = [0.5, 0.5, 0.5]

# Convert to Linear RGB
linear_color = srgb_to_linear(srgb_color)

print("sRGB color:", srgb_color)
print("Linear RGB color:", linear_color)

Explanation:

convert_channel Function: This function takes an individual color channel value and applies the conversion formula.
srgb_to_linear Function: This function takes an sRGB color (a list of three values for R, G, and B) and applies the convert_channel function to each channel.

This function should be used within a loop or processing function to convert all colors in your dataset as needed.

To filter your list of .pache assets placed in the Resources folder in Unity, you can use a script to load all assets of the specified type from the Resources folder and then filter them based on your criteria.

Here’s a C# script that you can use to filter and list .pache assets:

Create a C# script in your Unity project: You can name the script PacheAssetFilter.cs or any name you prefer.
Implement the script:

using UnityEngine;
using UnityEditor;
using System.IO;
using System.Collections.Generic;

public class PacheAssetFilter : MonoBehaviour
{
    // Specify the folder where your .pache assets are located
    private const string resourcesFolder = "Assets/Resources";
    private const string fileExtension = ".pache";

    [MenuItem("Tools/Filter Pache Assets")]
    public static void FilterPacheAssets()
    {
        List<string> pacheAssets = new List<string>();

        // Get all .pache files in the specified folder and its subfolders
        string[] files = Directory.GetFiles(resourcesFolder, "*" + fileExtension, SearchOption.AllDirectories);

        // Filter the assets
        foreach (string file in files)
        {
            string assetPath = file.Substring(file.IndexOf("Assets"));
            if (AssetDatabase.LoadAssetAtPath<Object>(assetPath) != null)
            {
                pacheAssets.Add(assetPath);
            }
        }

        // Output the filtered list to the console
        Debug.Log("Filtered .pache Assets:");
        foreach (string asset in pacheAssets)
        {
            Debug.Log(asset);
        }

        // Optionally, you can perform additional operations on the filtered list
    }
}

Explanation:

Resources Folder Path: The script sets the resourcesFolder constant to point to the Resources folder in your Unity project. You can adjust this path if your .pache assets are in a different folder.
File Extension: The script sets the fileExtension constant to .pache.
Menu Item: The [MenuItem] attribute allows you to run this script from the Unity Editor menu (Tools -> Filter Pache Assets).
Filtering Assets: The script uses Directory.GetFiles to find all .pache files in the specified folder and its subfolders. It then filters the assets by loading them with AssetDatabase.LoadAssetAtPath.
Output to Console: The filtered list of .pache assets is output to the Unity console.

How to Use:

Create the Script: Copy the above script into a new C# script file in your Unity project.
Run the Script: In the Unity Editor, go to Tools -> Filter Pache Assets to run the script. The filtered list of .pache assets will be displayed in the console.

This script provides a basic framework for filtering .pache assets in Unity. You can expand and customize it further based on your specific requirements, such as applying additional filters or performing other operations on the filtered assets.

If an asset has sub-assets in Unity, you can use the AssetDatabase to load the main asset and then access its sub-assets. Sub-assets can be loaded using AssetDatabase.LoadAllAssetsAtPath, which returns an array of all assets at the specified path, including the main asset and any sub-assets.

Here’s how you can modify the script to handle assets with sub-assets:

Create a C# script in your Unity project: You can name the script PacheAssetFilterWithSubAssets.cs or any name you prefer.
Implement the script:

using UnityEngine;
using UnityEditor;
using System.IO;
using System.Collections.Generic;

public class PacheAssetFilterWithSubAssets : MonoBehaviour
{
    // Specify the folder where your .pache assets are located
    private const string resourcesFolder = "Assets/Resources";
    private const string fileExtension = ".pache";

    [MenuItem("Tools/Filter Pache Assets with Sub-Assets")]
    public static void FilterPacheAssets()
    {
        List<string> pacheAssets = new List<string>();

        // Get all .pache files in the specified folder and its subfolders
        string[] files = Directory.GetFiles(resourcesFolder, "*" + fileExtension, SearchOption.AllDirectories);

        // Filter the assets and check for sub-assets
        foreach (string file in files)
        {
            string assetPath = file.Substring(file.IndexOf("Assets"));
            Object mainAsset = AssetDatabase.LoadAssetAtPath<Object>(assetPath);

            if (mainAsset != null)
            {
                pacheAssets.Add(assetPath);
                // Load all sub-assets
                Object[] subAssets = AssetDatabase.LoadAllAssetsAtPath(assetPath);

                // Output the main asset and its sub-assets to the console
                Debug.Log($"Main Asset: {assetPath}");
                foreach (Object subAsset in subAssets)
                {
                    if (subAsset != mainAsset) // Avoid listing the main asset again
                    {
                        Debug.Log($"  Sub-Asset: {subAsset.name} ({subAsset.GetType()})");
                    }
                }
            }
        }

        // Optionally, you can perform additional operations on the filtered list
        Debug.Log("Filtered .pache Assets:");
        foreach (string asset in pacheAssets)
        {
            Debug.Log(asset);
        }
    }
}

Explanation:

Resources Folder Path: The script sets the resourcesFolder constant to point to the Resources folder in your Unity project. You can adjust this path if your .pache assets are in a different folder.
File Extension: The script sets the fileExtension constant to .pache.
Menu Item: The [MenuItem] attribute allows you to run this script from the Unity Editor menu (Tools -> Filter Pache Assets with Sub-Assets).
Filtering Assets: The script uses Directory.GetFiles to find all .pache files in the specified folder and its subfolders.
Loading Assets and Sub-Assets: For each .pache file found, the script loads the main asset using AssetDatabase.LoadAssetAtPath. It then loads all assets at the same path (main asset and sub-assets) using AssetDatabase.LoadAllAssetsAtPath.
Output to Console: The script outputs the main asset and its sub-assets to the Unity console.

How to Use:

Create the Script: Copy the above script into a new C# script file in your Unity project.
Run the Script: In the Unity Editor, go to Tools -> Filter Pache Assets with Sub-Assets to run the script. The filtered list of .pache assets, along with their sub-assets, will be displayed in the console.

This script provides a framework for filtering .pache assets and accessing any sub-assets they contain. You can expand and customize it further based on your specific requirements.