dzfRabbit However, our art team is used to using Gamma's workflow to output art resources, so almost all of the image resources we use are sRGB compliant images
I'm not sure what exactly you mean by "sRGB compliant", but in general also when using linear color space in Unity or any game toolkit, you will still be authoring your images as normal 8 bits per channel (24bit or 32 bit) sRGB images. Linear color space does not imply that you need to be using HDR input images, except for skies and IBL maps. Linear vs gamma color space just determines in which color space blending and lighting calculations take place. Input images (your textures) and output images (your screen buffer) are still in normal sRGB color space (with a few exceptions).
dzfRabbit but performs poorly when switching to linear space. This is shown in the image below:
The problem here is likely that if the RGB channels contain high values (like 255 white or 255 blue, normalized 1.0) and the alpha channel is very transparent (e.g. normalized alpha or 0.1). Unfortunately by definition, the alpha channel is treated linearly in both gamma and linear space, which makes light transparent values brighter, while making opaque dark values darker. For example, in gamma space two additively alphablended values of blue 1.0 and alpha 0.1 would result in 1.0*0.1 + 1.0*0.1 = 0.2. In linear space, that's
toSRGB( toLinear(1.0)*0.1 + toLinear(1.0)*0.1)
= toSRGB( 1.0*0.1 + 1.0*0.1)
= toSRGB( 0.2 ) ~= 0.2 ^ (1 / 2.2)
= ~0.48
So the difference is 0.2 to 0.48 in blue intensity for the very transparent light blue case! Now the problem is that banding will occur due to spreading out previously hard-to-see values of 0-0.2 to now almost 0-0.5.
dzfRabbit We thought we might be able to solve this problem if we could use linear image resources instead of sRGB images
Unfortunately the problem is not how your input images are saved, it is how Photoshop (or whatever image editor) previews any blending and transparency for you. If your artists author art so that it looks good with gamma-space blending, it will look off with linear-space blending, and vice versa. If Photoshop only previews in gamma-space blending, then that's a problem. I would then hightly suggest to switch your Unity project to gamma space.
Unfortunately it might be difficult to author the desired blending in linear space with 32bits sRGB images, both in finding image editors that support linear blending in the first place, and even if that problem is solved, how to author highly transparent but bright parts (see below why that's a problem) and still save it as 32bit sRGB images.
dzfRabbit So we tried to convert the sRGB resource images to Linear images in PhotoShop or other image processing software.
What exactly did you do to convert to "linear images", and what format did you save it in?
If you mean that you are saving all images in .exr floating point format with 16 or 32bit per channel now, that's not recommended at all, as it would be much more expensive in terms of both memory consumption and also performance-wise.
dzfRabbit The resulting image looked like a mess, but when I imported it into the Unity project and configured the Texture correctly, it performed surprisingly well.
Did you export your image as .exr or other floating point format? By "worked surprisingly well", do you mean that the banding disappeared (which is expected), or that the values became darker as well (which would be surprising)?
dzfRabbit . I also took this processed image and replaced the original image resource in Spine, expecting it to solve all the problems we were having.
Again the question, how exactly did you "process" this image?
