colormanagement module

import substance_painter as sp

# Open a project using legacy color management

# Get the currently displayed stack
stack = sp.textureset.get_active_stack()

# Define a color (web standard dark orange #ff8c00)
dark_orange_sRGB = sp.colormanagement.Color(
    # r, g, b components in floating point format
    1.0, 0.54902, 0.0,
    # Specify r,g,b values are encoded in sRGB
    sp.colormanagement.GenericColorSpace.sRGB)

dark_orange_linear = sp.colormanagement.Color(
    # r, g, b components in floating point format
    1.0, 0.26225, 0.0,
    # Specify r,g,b values are encoded in working space (Linear sRGB in legacy mode)
    sp.colormanagement.GenericColorSpace.Working)

# Here print the internal data of the colors. They should match what have been set above.
print('Internal color data:')
print(f'  dark_orange_sRGB: {dark_orange_sRGB.value_raw}, {dark_orange_sRGB.color_space}')
print(f'  dark_orange_linear: {dark_orange_linear.value_raw}, {dark_orange_linear.color_space}')

def _pretty_str(value):
    return f'({value[0]:.5f}, {value[1]:.5f}, {value[2]:.5f})'

# Here use the Color object interface to access data encoded in working space.
# values should be equivalent to dark_orange_linear.value_raw
print('Linear color data:')
print(f'  dark_orange_sRGB.working: {_pretty_str(dark_orange_sRGB.working)}')
print(f'  dark_orange_sRGB.convert(working): {_pretty_str(dark_orange_sRGB.convert(sp.colormanagement.GenericColorSpace.Working))}')
print(f'  dark_orange_linear.working: {_pretty_str(dark_orange_linear.working)}')
print(f'  dark_orange_linear.value_raw: {_pretty_str(dark_orange_linear.value_raw)}')

# Here use the Color object interface to access data encoded in sRGB space.
# values should be equivalent to dark_orange_sRGB.value_raw
print('sRGB color data:')
print(f'  dark_orange_sRGB.sRGB: {_pretty_str(dark_orange_sRGB.sRGB)}')
print(f'  dark_orange_linear.sRGB: {_pretty_str(dark_orange_linear.sRGB)}')
print(f'  dark_orange_linear.convert(sRGB): {_pretty_str(dark_orange_linear.convert(sp.colormanagement.GenericColorSpace.sRGB))}')
print(f'  dark_orange_sRGB.value_raw: {_pretty_str(dark_orange_sRGB.value_raw)}')

def _insert_fill_with_uniform_basecolor(color):
    position = sp.layerstack.InsertPosition.from_textureset_stack(stack)
    fill = sp.layerstack.insert_fill(position)
    fill.set_source(sp.textureset.ChannelType.BaseColor, color)
    return fill

# Insert two fill layers with both colors above
fill_sRGB = _insert_fill_with_uniform_basecolor(dark_orange_sRGB)
fill_linear = _insert_fill_with_uniform_basecolor(dark_orange_linear)

# At this point you should have 2 fill layers inside your stack that look exactly the
# same with the same color visually.

# Additionaly, if you are not confortable with color spaces, you can create a Color object
# without specifying any color space. In this case the color space will be
# deduced depending on the context where this color is used (sRGB on color managed
# channels such as BaseColor, raw otherwise).

# sRGB is the most common color space used for computer screens, this is why many color pickers
# will give you sRGB data. sRGB is also the standard color space for the web, so a lot of color
# data you can get from the web will be sRGB encoded.
# This is why we assume sRGB for color managed channels.

# Since we need the context to deduce the color space, you can't use any methods that
# would do explicit color space conversion. Instead we exposed another flexible property.
# See the example below:

# Define a color (web standard dark orange #ff8c00)
dark_orange_no_colorspace = sp.colormanagement.Color(
    # r, g, b components in floating point format
    1.0, 0.54902, 0.0)

# Print assumed sRGB data and compare with the colors defined above with proper color space
print('sRGB color data for color with undefined color space:')
print(f'  dark_orange_no_colorspace: {dark_orange_no_colorspace.value_raw}, {dark_orange_no_colorspace.color_space}')
print(f'  dark_orange_no_colorspace.value: {_pretty_str(dark_orange_no_colorspace.value)}')
print(f'  dark_orange_sRGB.sRGB: {_pretty_str(dark_orange_sRGB.sRGB)}')
print(f'  dark_orange_linear.sRGB: {_pretty_str(dark_orange_linear.sRGB)}')
# The calls below would raise due to the lack of color space.
# print(f'  dark_orange_no_colorspace.sRGB: {_pretty_str(dark_orange_no_colorspace.sRGB)}')
# print(f'  dark_orange_no_colorspace.working: {_pretty_str(dark_orange_no_colorspace.working)}')
# print(f'  dark_orange_no_colorspace.convert(working): {_pretty_str(dark_orange_no_colorspace.convert(sp.colormanagement.GenericColorSpace.Working)}')

# Insert a fill layer with the color with undefined color space
fill_no_colorspace = _insert_fill_with_uniform_basecolor(dark_orange_no_colorspace)

# At this point you should have 3 fill layers inside your stack that look exactly the
# same with the same color visually.

# Select the Fill layer
sp.layerstack.set_selected_nodes([fill_sRGB, fill_linear, fill_no_colorspace])