kramv - fix display of images to match Figma/Photoshop

These apps do all filtering, blends, and premul in srgb space.  This is totally wrong, but to match have to emulate it.  The premul code applies the srgbToLinear conversion (not pow2.2) to the alpha before shader premul.  pow2.2 is not a good approximation, with 20% of a black to white gradient not matching up.   Note that kram already has isPremul and isPremulRGB.  These correspond with linear and srgb premul to the texture.  See below for how they differ.

sRGB data must be held in an RGBA8Unorm (not RGBAUnorm_srgb) buffer to emulate what these tools do.  This is counter-intuitive.  But premul is directl is then correlated between alpha and rgb.  When premul is applied to srgb, the rgb values are < alpha even when rgb = 111 due to engamma of rgb.  This affects fromPremul() calls which try to divide out the alpha.

isPremul:
     res = srgbToLinear( srgb ) * a )
     build and filter mips in linear space
     res2 = linearToSrgb( res )
     write out res2 to BC7_srgb

isPremulRGB:
    res = srgb * a
    build and filter mips in srgb space
    write out res to BC7

Author: alecazam

Diff for: kramv/KramRenderer.mm

@@ -376,27 +376,108 @@ - (void)_loadMetalWithView:(nonnull MTKView *)view
     // false is good for srgb -> rgba16f
     // true is good for non-srgb -> rgba16f
     CGColorSpaceRef viewColorSpace;
-    MTLPixelFormat format;
+    MTLPixelFormat format = MTLPixelFormatRGBA16Float;
 
     // This doesn't look like Figma or Photoshop for a rgb,a = 255,0 to 255,1 gradient across a 256px wide rect.   The shader is saturating
     // the color to 0,1.  So can get away with SRGB color space for now.
     // This also lines up with Preview.
     //viewColorSpace  = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGBLinear);
 
 
+    CAMetalLayer* metalLayer = (CAMetalLayer*)[view layer];
 
     // was using 16f so could sample hdr images from it
     //  and also so hdr data went out to the display
-    format = MTLPixelFormatRGBA16Float;
-    viewColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
-    //viewColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceLinearSRGB);
+    uint32_t colorSpaceChoice = 1;
+    switch(colorSpaceChoice) {
+        default:
+        case 0:
+            // This is best so far
+            format = MTLPixelFormatRGBA16Float;
+            viewColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
+            //viewColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceLinearSRGB);
+            break;
+            
+        case 1: {
+            // Display P3 is a standard made by Apple that covers the same colour space as DCI-P3, but uses the more neutral D65 as a white point instead of the green white of the DCI standard.
+            // Ideally feed 16-bit color to P3.
+            
+            // This also works
+            // 25% larger than srgb
+            format = MTLPixelFormatRGBA16Float;
+           
+            // This is industry format
+            // viewColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceDCIP3);
+            
+            // This isn't edr
+            // viewColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceDisplayP3);
+            
+            // Use this because it exists from 10.14.3+
+            viewColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceExtendedLinearDisplayP3);
+           
+            // don't set this yet.
+            // metalLayer.wantsExtendedDynamicRangeContent = YES;
+            
+            // https://developer.apple.com/videos/play/wwdc2021/10161/
+            
+            /* Can detect if on HDR display or not
+                user can mod the brightness, or move to another monitor,
+                need to listen for notification when this changes.
+             
+            NSScreen* screen = NSScreen.mainScreen;
+            
+            // This reports 1
+            CGFloat val1 = screen.maximumExtendedDynamicRangeColorComponentValue;
+            
+            // This is 16
+            CGFloat maxPot =  screen.maximumPotentialExtendedDynamicRangeColorComponentValue;
+            
+            // This is 0
+            CGFloat maxRef = screen.maximumReferenceExtendedDynamicRangeColorComponentValue;
+            */
+            
+            // M1 monitor
+            
+            
+            break;
+        }
+        case 2:
+            // This doesn't match wnen srgb is turned off on TestColorGradient
+            format = MTLPixelFormatRGBA8Unorm_sRGB;
+            viewColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
+            
+            // this looks totally wrong
+            //viewColorSpace = CGColorSpaceCreateWithName(kCGColorLinearSpaceSRGB);
+            break;
+            
+        /*
+        case 3: {
+            // There is an exrMetadata field on NSView to set as well.
+            // https://developer.apple.com/documentation/metal/hdr_content/using_color_spaces_to_display_hdr_content?language=objc
+            
+            // Rec2020 color primaries, with PQ Transfer function.
+            // Would have to get into Rec2020 colors to set this, also go from 10bit
+            format = MTLPixelFormatBGR10A2Unorm;
+            viewColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceITUR_2100_PQ);
+            
+            metalLayer.wantsExtendedDynamicRangeContent = YES;
+            
+            // https://developer.apple.com/documentation/metal/hdr_content/using_system_tone_mapping_on_video_content?language=objc
+            // must do os version check on this
+            // 1.0 is 100 nits of output
+            CAEDRMetadata* edrMetaData = [CAEDRMetadata HDR10MetadataWithMinLuminance: 0.005 maxLuminance: 1000 opticalOutputScale: 100];
+            metalLayer.EDRMetadata = edrMetaData;
+            
+            break;
+        }
+        */
+    }
+    
 
-    // This doesn't work with or without srgb color space
-    //format = MTLPixelFormatRGBA8Unorm_sRGB;
-   
     view.colorPixelFormat = format;
     view.colorspace = viewColorSpace;
 
+    CGColorSpaceRelease(viewColorSpace);
 
     view.depthStencilPixelFormat = MTLPixelFormatDepth32Float_Stencil8;
     view.sampleCount = 1;
@@ -1282,6 +1363,7 @@ - (void)_updateGameState
 
     uniforms.isNormal = _showSettings->texContentType == TexContentTypeNormal;
     uniforms.doShaderPremul = _showSettings->doShaderPremul;
+    uniforms.isSrgbInput = _showSettings->isSRGBShown && isSrgbFormat(_showSettings->originalFormat);
     uniforms.isSigned = _showSettings->isSigned;
     uniforms.isSwizzleAGToRG = _showSettings->isSwizzleAGToRG;
 

Diff for: kramv/Shaders/KramShaders.h

@@ -127,6 +127,7 @@ struct Uniforms {
     bool isSDF;
     bool isPreview; // render w/lighting, normals, etc
     bool isUVPreview; // show uv overlay
+    bool isSrgbInput;
 
     bool is3DView;
     bool isNormalMapPreview;  // for isNormal or combined

Diff for: kramv/Shaders/KramShaders.metal

@@ -915,6 +915,41 @@ float3 calculateViewDir(float3 worldPos, float3 cameraPosition) {
 // This is writing out to 16F and could write snorm data, but then that couldn't be displayed.
 // So code first converts to Unorm.
 
+float srgbToLinear(float s) {
+    s = saturate(s);
+    //return (s < 0.04044823) ? (s / 12.92)
+    //                                 : pow((s + 0.055) / 1.055, 2.4);
+    
+    return (s < 0.04044823) ? (s * ( 1.0 / 12.92 ))
+                                     : pow((s + 0.055) * ( 1.0 / 1.055 ), 2.4);
+    
+}
+
+void shaderPremul(thread float4& c, bool isSrgbInput) {
+    float alpha = c.a;
+    
+    // This is because Figma/PS do all filering/blends in premul srgb.
+    // So srgbToLinear( srgb * a ) = srgbToLinear( srgb ) * srgbToLinear( a ).
+    // Emulating srgb blends also takes two alpha or access to dst.
+    // Shader would need to export srgbToLinear( 1 - a ) for dstColor,
+    // but that's not correct to blend alpha.  Alpha still needs linear 1-a.
+    
+    // TODO: make this one of the premul options (default for png)
+    if (isSrgbInput)
+    {
+        // can tell difference in last 20% of TestAlphaGradient.png
+        //c.a = pow(c.a, 2.2); // approx
+        
+        c.a = srgbToLinear(c.a);
+    }
+    
+    c = toPremul(c);
+    
+    // Note: be careful fromPremul would need to do similar math
+    // have an alpha that is much smaller in rgb, than the blend alpha.
+    c.a = alpha;
+}
+
 float4 DrawPixels(
     ColorInOut in [[stage_in]],
     bool facing,
@@ -1000,7 +1035,7 @@ float4 DrawPixels(
 
             // to premul, but also need to see without premul
             if (uniforms.doShaderPremul) {
-                c = toPremul(c);
+                shaderPremul(c, uniforms.isSrgbInput);
             }
         }
 
@@ -1050,15 +1085,15 @@ float4 DrawPixels(
                 // Note: premul on signed should occur while still signed, since it's a pull to zoer
                 // to premul, but also need to see without premul
                 if (uniforms.doShaderPremul) {
-                    c = toPremul(c);
+                    shaderPremul(c, uniforms.isSrgbInput);
                 }
 
                 sc = c;
                 c.xyz = toUnorm(c.xyz);
             }
             else {
                 if (uniforms.doShaderPremul) {
-                    c = toPremul(c);
+                    shaderPremul(c, uniforms.isSrgbInput);
                 }
             }