okhsl

la_kernel.c

@@ -403,8 +403,8 @@ int laGetReady(){
 
     //XDestroyWindow(MAIN.dpy, win);
 
-    MAIN.ColorAccessCorrectGamma = 1;
-    MAIN.Gamma = 1;//2.2; ...?
+    //MAIN.ColorAccessCorrectGamma = 1;
+    MAIN.Gamma = //2.2; //...?
 
     //interactions:
     MAIN.TopFramerate = 60;
@@ -830,12 +830,12 @@ real* laAccentColor(int which){
 }
 void la_RefreshBoxedThemeColor(laBoxedTheme* bt){
     real hcy[3];
-    tnsRGBtoHCY(MAIN.CurrentTheme->Color,hcy);
-    hcy[2]=bt->NormalY; tnsHCYtoRGB(hcy, bt->Normal); bt->Normal[3]=bt->Alpha;
-    hcy[2]=bt->ActiveY; tnsHCYtoRGB(hcy, bt->Active); bt->Active[3]=bt->Alpha;
-    hcy[2]=bt->BorderY; tnsHCYtoRGB(hcy, bt->Border); bt->Border[3]=1;
-    hcy[2]=bt->TextY;   tnsHCYtoRGB(hcy, bt->Text); bt->Text[3]=1;
-    hcy[2]=bt->TextActiveY; tnsHCYtoRGB(hcy, bt->TextActive); bt->TextActive[3]=1;
+    tnsRGB2HCY(MAIN.CurrentTheme->Color,hcy);
+    hcy[2]=bt->NormalY; tnsHCY2RGB(hcy, bt->Normal); bt->Normal[3]=bt->Alpha;
+    hcy[2]=bt->ActiveY; tnsHCY2RGB(hcy, bt->Active); bt->Active[3]=bt->Alpha;
+    hcy[2]=bt->BorderY; tnsHCY2RGB(hcy, bt->Border); bt->Border[3]=1;
+    hcy[2]=bt->TextY;   tnsHCY2RGB(hcy, bt->Text); bt->Text[3]=1;
+    hcy[2]=bt->TextActiveY; tnsHCY2RGB(hcy, bt->TextActive); bt->TextActive[3]=1;
     int *tm=&bt->LM,*tp=&bt->LP;
     for(int i=0;i<4;i++){
         tm[i]=bt->Margins[i]*LA_RH*MAIN.MarginSize;
@@ -846,24 +846,24 @@ void la_RefreshThemeColorSelf(laTheme* th){
     tnsVectorCopy3d(th->AccentColor, th->CursorColor);   th->CursorColor[3]=th->CursorAlpha;
     tnsVectorCopy3d(th->AccentColor, th->SelectionColor);th->SelectionColor[3]=th->SelectionAlpha;
     real hcy[3], usehcy[3];
-    tnsRGBtoHCY(th->Color,hcy); tnsVectorCopy3d(hcy,usehcy);
-    usehcy[2]=th->VertexBrightness; tnsHCYtoRGB(usehcy, th->VertexColor); th->VertexColor[3]=th->VertexTransparency;
-    usehcy[2]=th->EdgeBrightness;   tnsHCYtoRGB(usehcy, th->EdgeColor);   th->EdgeColor[3]=th->EdgeTransparency;
+    tnsRGB2HCY(th->Color,hcy); tnsVectorCopy3d(hcy,usehcy);
+    usehcy[2]=th->VertexBrightness; tnsHCY2RGB(usehcy, th->VertexColor); th->VertexColor[3]=th->VertexTransparency;
+    usehcy[2]=th->EdgeBrightness;   tnsHCY2RGB(usehcy, th->EdgeColor);   th->EdgeColor[3]=th->EdgeTransparency;
     tnsVectorCopy3d(th->AccentColor, th->SVertexColor); th->SVertexColor[3]=th->SelectedVertexTransparency;
     tnsVectorCopy3d(th->AccentColor, th->SEdgeColor); th->SEdgeColor[3]=th->SelectedEdgeTransparency;
     tnsVectorCopy3d(th->AccentColor, th->SFaceColor); th->SFaceColor[3]=th->SelectedFaceTransparency;
 }
 void la_RefreshThemeColor(laTheme* th){
     real hcy[3], usehcy[3], normalhcy[3];
-    tnsRGBtoHCY(th->Color,hcy);
+    tnsRGB2HCY(th->Color,hcy);
     la_RefreshThemeColorSelf(th);
     for(laBoxedTheme* bt = th->BoxedThemes.pFirst;bt;bt=bt->Item.pNext){
         la_RefreshBoxedThemeColor(bt);
         (*bt->BackRef) = bt;
-        tnsRGBtoHCY(bt->Text, usehcy); usehcy[1]*=th->InactiveSaturation;
-        tnsHCYtoRGB(usehcy, bt->TextInactive); bt->TextInactive[3]=th->InactiveMix;
-        tnsRGBtoHCY(bt->Normal, normalhcy); normalhcy[1]*=th->InactiveSaturation;
-        tnsHCYtoRGB(normalhcy, bt->Inactive); bt->Inactive[3]=bt->Alpha*th->InactiveMix;
+        tnsRGB2HCY(bt->Text, usehcy); usehcy[1]*=th->InactiveSaturation;
+        tnsHCY2RGB(usehcy, bt->TextInactive); bt->TextInactive[3]=th->InactiveMix;
+        tnsRGB2HCY(bt->Normal, normalhcy); normalhcy[1]*=th->InactiveSaturation;
+        tnsHCY2RGB(normalhcy, bt->Inactive); bt->Inactive[3]=bt->Alpha*th->InactiveMix;
     }
 }
 
@@ -4772,7 +4772,7 @@ void la_RegenerateWireColors(){
     real hcy[]={0.0,0.8,0.6}; hcy[1]=t->WireSaturation; hcy[2]=t->WireBrightness;
     for(int i=0;i<MAIN.WireColorSlices;i++){
         hcy[0]=(real)i/(real)MAIN.WireColorSlices;
-        tnsHCYtoRGB(hcy, &MAIN.WireColorCache[i*4]); MAIN.WireColorCache[i*4+3]=t->WireTransparency;
+        tnsHCY2RGB(hcy, &MAIN.WireColorCache[i*4]); MAIN.WireColorCache[i*4+3]=t->WireTransparency;
     }
 }
 void la_SendWireVerts(real x1, real y1, real x2, real y2, real circle_r){

la_tns.h

@@ -4,6 +4,12 @@
 //#include "tinycthread.h"
 #include <float.h>
 
+#ifdef __cplusplus
+extern "C" const char* TNS_SHADER_COLOR_COMMON;
+#else
+extern const char* TNS_SHADER_COLOR_COMMON;
+#endif
+
 #define TNS_PI 3.1415926535897932384626433832795
 #define deg(r) r / TNS_PI * 180.0
 #define rad(d) d *TNS_PI / 180.0
@@ -58,7 +64,7 @@ struct _tnsShader{
     int iTexColor,iTexNormal,iTexGPos;
     int iTexColorMS;
     int iMultiplyColor, StateMultiplyColor;
-    int iTextureMode, StateTextureMode;
+    int iTextureMode, StateTextureMode, iColorMode;
     int iSampleAmount, StateSampleAmount;
 
     int uViewDir,uViewPos,uFOV;
@@ -980,14 +986,18 @@ real tnsDirectionToRad(tnsVector2d Dir);
 void tnsConvert44df(tnsMatrix44d from, tnsMatrix44f to);
 int tnsTrangleLineBoundBoxTest(tnsRenderTriangle *rt, tnsRenderLine *rl);
 
+#define tnsVectorSet2(to, x,y)\
+    {(to)[0]=x;(to)[1]=y;}
 #define tnsVectorSet3(to, x,y,z)\
     {(to)[0]=x;(to)[1]=y;(to)[2]=z;}
 #define tnsVectorSet4(to, x,y,z,w)\
     {(to)[0]=x;(to)[1]=y;(to)[2]=z;(to)[3]=w;}
+#define tnsVectorSet2v(to, from)\
+    tnsVectorSet2(to,(from)[0],(from)[1])
 #define tnsVectorSet3v(to, from)\
-    tnsVectorSet3(to,from[0],from[1],from[2])
+    tnsVectorSet3(to,(from)[0],(from)[1],(from)[2])
 #define tnsVectorSet4v(to, from)\
-    tnsVectorSet4(to,from[0],from[1],from[2],from[3])
+    tnsVectorSet4(to,(from)[0],(from)[1],(from)[2],(from)[3])
 
 real tnsDistIdv2(real x1, real y1, real x2, real y2);
 real tnsDist3dv(tnsVector3d l, tnsVector3d r);
@@ -1205,6 +1215,7 @@ void tnsActiveTexture(GLenum tex);
 void tnsBindTexture(tnsTexture *t);
 void tnsUnbindTexture();
 void tnsUniformUseTexture(tnsShader* s, int mode, int sample);
+void tnsUniformColorMode(tnsShader* s, int mode);
 void tnsUniformUseMultiplyColor(tnsShader* s, int enable);
 void tnsUseMaskTexture(tnsTexture *t);
 void tnsUseTexture(tnsTexture *t);
@@ -1293,7 +1304,7 @@ void tnsMakeQuad2d(real *arr, real x1, real y1, real x2, real y2, real x3, real
 void tnsMakeQuadT2d(real *arr, real x1, real y1, real x2, real y2, real x3, real y3, real x4, real y4);
 void tnsMakeQuad3d(real *arr, real x1, real y1, real z1, real x2, real y2, real z2, real x3, real y3, real z3, real x4, real y4, real z4);
 void tnsMakeQuad4d(real *arr, real x1, real y1, real z1, real w1, real x2, real y2, real z2, real w2, real x3, real y3, real z3, real w3, real x4, real y4, real z4, real w4);
-void tnsMakeCircle2d(real *arr, int slices, real ctrX, real ctrY, real r);
+void tnsMakeCircle2d(real *arr, int slices, real ctrX, real ctrY, real r, int jump);
 void tnsMakeArc2d(real *arr, int slices, real ctrX, real ctrY, real r, real rad_begin, real rad_end);
 void tnsMakeRing2d(real *arr, int *index, int slices, real ctrX, real ctrY, real r1, real r2);
 
@@ -1320,8 +1331,8 @@ void tnsSingleLogToLinear(real *a, real gamma);
 void tnsLinearToLog(real *rgb, real gamma);
 void tnsLogToLinear(real *rgb, real gamma);
 void tnsRgbToLuminance(real *rgb);
-void tnsHCYtoRGB(real *hcy, real *rgb);
-void tnsRGBtoHCY(real *rgb, real *hcy);
+void tnsHCY2RGB(real *hcy, real *rgb);
+void tnsRGB2HCY(real *rgb, real *hcy);
 
 tnsLineStrip *tnsCreateLineStrip();
 tnsLineStripPoint *tnsAppendPoint(tnsLineStrip *ls, real X, real Y, real Z);

la_tns_kernel.c

@@ -117,6 +117,7 @@ const char LA_IMM_FRAGMENT_SHADER[] = "#version 330\n\
 uniform sampler2D TexColor;\
 uniform sampler2DMS TexColorMS;\
 uniform int TextureMode;\n\
+uniform int ColorMode;\n\
 uniform int MultiplyColor;\n\
 uniform int SampleAmount;\n\
 uniform int UseNormal;\n\
@@ -128,6 +129,7 @@ in vec3 fGPos;\n\
 layout(location = 0) out vec4 outColor;\n\
 layout(location = 1) out vec3 outNormal;\n\
 layout(location = 2) out vec3 outGPos;\n\
+#with TNS_SHADER_COLOR_COMMON\n\
 void main(){\n\
     vec4 color=vec4(1,0,1,1);\n\
     if(TextureMode==0){ color = fColor;}\n\
@@ -151,6 +153,7 @@ void main(){\n\
         vec3 oNormal=fNormal; if(view<0){ oNormal=-fNormal; }\n\
         outNormal = oNormal;\n\
     }\n\
+    if(ColorMode!=0){ color.rgb=okhsl_to_srgb(color.rgb); }\n\
     outColor = color;\n\
     outGPos = fGPos;\n\
 }";
@@ -526,7 +529,9 @@ void tnsShaderApplyShadowMatrix(tnsShader *tns, tnsMatrix44d m){
     glUniformMatrix4fv(tns->iShadow, 1, 0, mf);
 }
 
-//--------------------Export
+char* tnsEnsureShaderCommoms(char* Content){
+    return strSub(Content,"#with TNS_SHADER_COLOR_COMMON",TNS_SHADER_COLOR_COMMON);
+}
 int tnsNewVertexShader(char *Content){
     int status = 0;
     char error[1024];
@@ -537,7 +542,8 @@ int tnsNewVertexShader(char *Content){
 
     VertexShaderObject = glCreateShader(GL_VERTEX_SHADER);
 
-    glShaderSource(VertexShaderObject, 1, &Content, 0);
+    char* UseContent=tnsEnsureShaderCommoms(Content);
+    glShaderSource(VertexShaderObject, 1, &UseContent, 0); free(UseContent);
     glCompileShader(VertexShaderObject);
     glGetShaderiv(VertexShaderObject, GL_COMPILE_STATUS, &status);
     if (status == GL_FALSE){
@@ -559,7 +565,8 @@ int tnsNewFragmentShader(char *Content){
 
     FragmentShaderObject = glCreateShader(GL_FRAGMENT_SHADER);
 
-    glShaderSource(FragmentShaderObject, 1, &Content, 0);
+    char* UseContent=tnsEnsureShaderCommoms(Content);
+    glShaderSource(FragmentShaderObject, 1, &UseContent, 0); free(UseContent);
     glCompileShader(FragmentShaderObject);
     glGetShaderiv(FragmentShaderObject, GL_COMPILE_STATUS, &status);
     if (status == GL_FALSE){
@@ -581,7 +588,8 @@ int tnsNewGeometryShader(char *Content){
 
     GeometryShaderObject = glCreateShader(GL_GEOMETRY_SHADER);
 
-    glShaderSource(GeometryShaderObject, 1, &Content, 0);
+    char* UseContent=tnsEnsureShaderCommoms(Content);
+    glShaderSource(GeometryShaderObject, 1, &UseContent, 0); free(UseContent);
     glCompileShader(GeometryShaderObject);
     glGetShaderiv(GeometryShaderObject, GL_COMPILE_STATUS, &status);
     if (status == GL_FALSE){
@@ -1976,6 +1984,9 @@ void tnsUniformUseMultiplyColor(tnsShader* s, int enable){
     int mode=enable?1:0;
     if(s->StateMultiplyColor != mode){ s->StateMultiplyColor=mode; glUniform1i(s->iMultiplyColor,mode); }
 }
+void tnsUniformColorMode(tnsShader* s, int mode){
+    glUniform1i(s->iColorMode,mode);
+}
 
 void tnsDraw2DTextureDirectly(tnsTexture *t, real x, real y, real w, real h){
     real Verts[8];
@@ -2644,7 +2655,7 @@ void tnsDrawToOffscreen(tnsOffscreen *toff, int HowMany, GLuint *AttachmentArray
     T->IsOffscreen = 1;
     T->BindedShader = 0;
 }
-//void tnsDrawToExtraColorAttachment(tnsOffscreen *toff){
+//void tnsDraw_toextraColorAttachment(tnsOffscreen *toff){
 //    if (!toff) return;
 //    if (!toff->pColor[1]){
 //        tnsCreate2DOffscreenMSAttachmentExtraColor(toff);
@@ -2654,7 +2665,7 @@ void tnsDrawToOffscreen(tnsOffscreen *toff, int HowMany, GLuint *AttachmentArray
 //    T->IsOffscreen = 1;
 //    T->BindedShader = 0;
 //}
-//void tnsDrawToExtraNormalAttachment(tnsOffscreen *toff){
+//void tnsDraw_toextraNormalAttachment(tnsOffscreen *toff){
 //    if (!toff) return;
 //    if (!toff->pColor[2]){
 //        tnsCreate2DOffscreenMSAttachmentExtraNormal(toff);
@@ -3811,17 +3822,17 @@ void tnsLinearToLog(real *rgb, real gamma){
     if (rgb[0] < 0) rgb[0] = 0;
     if (rgb[1] < 0) rgb[1] = 0;
     if (rgb[2] < 0) rgb[2] = 0;
-    rgb[0] = powf(rgb[0], gamma);
-    rgb[1] = powf(rgb[1], gamma);
-    rgb[2] = powf(rgb[2], gamma);
+    rgb[0] = pow(rgb[0], gamma);
+    rgb[1] = pow(rgb[1], gamma);
+    rgb[2] = pow(rgb[2], gamma);
 }
 void tnsLogToLinear(real *rgb, real gamma){
     if (rgb[0] < 0) rgb[0] = 0;
     if (rgb[1] < 0) rgb[1] = 0;
     if (rgb[2] < 0) rgb[2] = 0;
-    rgb[0] = powf(rgb[0], 1.0f / gamma);
-    rgb[1] = powf(rgb[1], 1.0f / gamma);
-    rgb[2] = powf(rgb[2], 1.0f / gamma);
+    rgb[0] = pow(rgb[0], 1.0f / gamma);
+    rgb[1] = pow(rgb[1], 1.0f / gamma);
+    rgb[2] = pow(rgb[2], 1.0f / gamma);
 }
 void tnsRgbToLuminance(real *rgb){
     real l;
@@ -3832,153 +3843,277 @@ void tnsRgbToLuminance(real *rgb){
     rgb[0] = rgb[1] = rgb[2] = l;
 }
 
-static const double LA_LUMA_WEIGHTS[]={ 0.2126, 0.7152, 0.0722 };
-void tnsHCYtoRGB(real *hcy, real *rgb){
-    double red, green, blue;
-    double Y_peak = 0., H_insec, X, m;
-    int H_sec;
+real _srgb_transfer_function(real a){
+	return .0031308f >= a ? 12.92f * a : 1.055f * powf(a, .4166666666666667f) - .055f;
+}
+real _srgb_transfer_function_inv(real a){
+	return .04045f < a ? powf((a + .055f) / 1.055f, 2.4f) : a / 12.92f;
+}
+void tnsRGB2OKLAB(real* rgb, real* oklab){
+    real l = 0.4122214708f * rgb[0] + 0.5363325363f * rgb[1] + 0.0514459929f * rgb[2];
+	real m = 0.2119034982f * rgb[0] + 0.6806995451f * rgb[1] + 0.1073969566f * rgb[2];
+	real s = 0.0883024619f * rgb[0] + 0.2817188376f * rgb[1] + 0.6299787005f * rgb[2];
 
-    double hue = hcy[0];
-    double chroma = hcy[1];
-    double luma = hcy[2];
-    double* weights=LA_LUMA_WEIGHTS;
+    real l_ = cbrt(l); real m_ = cbrt(m); real s_ = cbrt(s);
 
-    if (chroma < DBL_EPSILON){
-        red = green = blue = luma;
-    }else{
-        hue = fmod(hue, 1.0);
-        hue += hue < 0.0;
-        hue *= 6.0;
-
-        H_sec = (int)hue;
-
-        switch (H_sec){
-        case 0:
-            H_insec = hue - H_sec;
-            Y_peak = weights[0] + H_insec * weights[1];
-            chroma *= luma < Y_peak ? luma / Y_peak : (1. - luma) / (1. - Y_peak);
-            X = chroma * H_insec;
-            m = luma - (weights[0] * chroma + weights[1] * X);
-            red = m + chroma;
-            green = m + X;
-            blue = m;
-            break;
-        case 1:
-            H_insec = 1. - (hue - H_sec);
-            Y_peak = weights[1] + H_insec * weights[0];
-            chroma *= luma < Y_peak ? luma / Y_peak : (1. - luma) / (1. - Y_peak);
-            X = chroma * H_insec;
-            m = luma - (weights[0] * X + weights[1] * chroma);
-            red = m + X;
-            green = m + chroma;
-            blue = m;
-            break;
-        case 2:
-            H_insec = hue - H_sec;
-            Y_peak = weights[1] + H_insec * weights[2];
-            chroma *= luma < Y_peak ? luma / Y_peak : (1. - luma) / (1. - Y_peak);
-            X = chroma * H_insec;
-            m = luma - (weights[1] * chroma + weights[2] * X);
-            red = m;
-            green = m + chroma;
-            blue = m + X;
-            break;
-        case 3:
-            H_insec = 1. - (hue - H_sec);
-            Y_peak = weights[2] + H_insec * weights[1];
-            chroma *= luma < Y_peak ? luma / Y_peak : (1. - luma) / (1. - Y_peak);
-            X = chroma * H_insec;
-            m = luma - (weights[1] * X + weights[2] * chroma);
-            red = m;
-            green = m + X;
-            blue = m + chroma;
-            break;
-        case 4:
-            H_insec = hue - H_sec;
-            Y_peak = weights[2] + H_insec * weights[0];
-            chroma *= luma < Y_peak ? luma / Y_peak : (1. - luma) / (1. - Y_peak);
-            X = chroma * H_insec;
-            m = luma - (weights[0] * X + weights[2] * chroma);
-            red = m + X;
-            green = m;
-            blue = m + chroma;
-            break;
-        default:
-            H_insec = 1. - (hue - H_sec);
-            Y_peak = weights[0] + H_insec * weights[2];
-            chroma *= luma < Y_peak ? luma / Y_peak : (1. - luma) / (1. - Y_peak);
-            X = chroma * H_insec;
-            m = luma - (weights[0] * chroma + weights[2] * X);
-            red = m + chroma;
-            green = m;
-            blue = m + X;
-            break;
-        }
-    }
+    oklab[0]=0.2104542553f*l_ + 0.7936177850f*m_ - 0.0040720468f*s_;
+    oklab[1]=1.9779984951f*l_ - 2.4285922050f*m_ + 0.4505937099f*s_;
+    oklab[2]=0.0259040371f*l_ + 0.7827717662f*m_ - 0.8086757660f*s_;
+}
+void tnsOKLAB2RGB(real* oklab, real* rgb){
+    real l_ = oklab[0] + 0.3963377774f * oklab[1] + 0.2158037573f * oklab[2];
+    real m_ = oklab[0] - 0.1055613458f * oklab[1] - 0.0638541728f * oklab[2];
+    real s_ = oklab[0] - 0.0894841775f * oklab[1] - 1.2914855480f * oklab[2];
 
-    rgb[0] =red;
-    rgb[1] =green;
-    rgb[2] =blue;
-}
-void tnsRGBtoHCY(real *rgb, real *hcy){
-    double hue, chroma, luma;
-    double X, Y_peak = 0.;
-    int H_sec = 4, t = -1;
-    double* weights=LA_LUMA_WEIGHTS;
-
-    int ix[3] = {0, 1, 2};
-
-    if (rgb[0] < rgb[1]){
-        if (rgb[1] > rgb[2]){
-            if (rgb[0] < rgb[2]){
-                ix[1] = 2;
-                ix[2] = 1;
-                H_sec = 2;
-                t = 1;
-            }else{
-                ix[0] = 2;
-                ix[1] = 0;
-                ix[2] = 1;
-                H_sec = 2;
-            }
-        }
-    }else{
-        if (rgb[1] < rgb[2]){
-            if (rgb[0] < rgb[2]){
-                ix[0] = 1;
-                ix[1] = 0;
-                H_sec = 4;
-                t = 1;
-            }else{
-                ix[0] = 1;
-                ix[1] = 2;
-                ix[2] = 0;
-                H_sec = 6;
-            }
-        }else{
-            ix[0] = 2;
-            ix[2] = 0;
-            H_sec = 0;
-            t = 1;
-        }
-    }
+    real l = l_*l_*l_; real m = m_*m_*m_; real s = s_*s_*s_;
+
+    rgb[0]=+4.0767416621f * l - 3.3077115913f * m + 0.2309699292f * s;
+    rgb[1]=-1.2684380046f * l + 2.6097574011f * m - 0.3413193965f * s;
+    rgb[2]=-0.0041960863f * l - 0.7034186147f * m + 1.7076147010f * s;
+}
+real _compute_max_saturation(real a, real b){
+	real k0, k1, k2, k3, k4, wl, wm, ws;
+	if (-1.88170328f * a - 0.80936493f * b > 1){
+		k0 = +1.19086277f; k1 = +1.76576728f; k2 = +0.59662641f; k3 = +0.75515197f; k4 = +0.56771245f;
+		wl = +4.0767416621f; wm = -3.3077115913f; ws = +0.2309699292f;
+	}
+	else if (1.81444104f * a - 1.19445276f * b > 1){
+		k0 = +0.73956515f; k1 = -0.45954404f; k2 = +0.08285427f; k3 = +0.12541070f; k4 = +0.14503204f;
+		wl = -1.2684380046f; wm = +2.6097574011f; ws = -0.3413193965f;
+	}
+	else{
+		k0 = +1.35733652f; k1 = -0.00915799f; k2 = -1.15130210f; k3 = -0.50559606f; k4 = +0.00692167f;
+		wl = -0.0041960863f; wm = -0.7034186147f; ws = +1.7076147010f;
+	}
+	real S = k0 + k1 * a + k2 * b + k3 * a * a + k4 * a * b;
+	real k_l = +0.3963377774f * a + 0.2158037573f * b;
+	real k_m = -0.1055613458f * a - 0.0638541728f * b;
+	real k_s = -0.0894841775f * a - 1.2914855480f * b;
+	{
+		real l_ = 1.f + S * k_l;
+		real m_ = 1.f + S * k_m;
+		real s_ = 1.f + S * k_s;
+
+		real l = l_ * l_ * l_;
+		real m = m_ * m_ * m_;
+		real s = s_ * s_ * s_;
+
+		real l_dS = 3.f * k_l * l_ * l_;
+		real m_dS = 3.f * k_m * m_ * m_;
+		real s_dS = 3.f * k_s * s_ * s_;
+
+		real l_dS2 = 6.f * k_l * k_l * l_;
+		real m_dS2 = 6.f * k_m * k_m * m_;
+		real s_dS2 = 6.f * k_s * k_s * s_;
+
+		real f = wl * l + wm * m + ws * s;
+		real f1 = wl * l_dS + wm * m_dS + ws * s_dS;
+		real f2 = wl * l_dS2 + wm * m_dS2 + ws * s_dS2;
+
+		S = S - f * f1 / (f1 * f1 - 0.5f * f * f2);
+	}
+
+	return S;
+}
+void _find_cusp(real a, real b, real *l, real *c)
+{
+	real S_cusp = _compute_max_saturation(a, b);
+    real oklab[3]={1, S_cusp * a, S_cusp * b}; real rgb_at_max[3];
+    tnsOKLAB2RGB(oklab,rgb_at_max);
+	real L_cusp = cbrt(1.f / TNS_MAX3(rgb_at_max[0], rgb_at_max[1], rgb_at_max[2])); 
+	real C_cusp = L_cusp * S_cusp;
+	*l=L_cusp; *c=C_cusp;
+}
+real _find_gamut_intersection(real a, real b, real L1, real C1, real L0, real cusp_L, real cusp_C)
+{
+	real t;
+	if (((L1 - L0) * cusp_C - (cusp_L - L0) * C1) <= 0.f) {
+		t = cusp_C * L0 / (C1 * cusp_L + cusp_C * (L0 - L1));
+	}else{
+		t = cusp_C * (L0 - 1.f) / (C1 * (cusp_L - 1.f) + cusp_C * (L0 - L1));
+		{
+			real dL = L1 - L0; real dC = C1;
+
+			real k_l = +0.3963377774f * a + 0.2158037573f * b;
+			real k_m = -0.1055613458f * a - 0.0638541728f * b;
+			real k_s = -0.0894841775f * a - 1.2914855480f * b;
+
+			real l_dt = dL + dC * k_l;
+			real m_dt = dL + dC * k_m;
+			real s_dt = dL + dC * k_s;
+			{
+				real L = L0 * (1.f - t) + t * L1;
+				real C = t * C1;
+
+				real l_ = L + C * k_l;
+				real m_ = L + C * k_m;
+				real s_ = L + C * k_s;
+
+				real l = l_ * l_ * l_;
+				real m = m_ * m_ * m_;
+				real s = s_ * s_ * s_;
+
+				real ldt = 3 * l_dt * l_ * l_;
+				real mdt = 3 * m_dt * m_ * m_;
+				real sdt = 3 * s_dt * s_ * s_;
+
+				real ldt2 = 6 * l_dt * l_dt * l_;
+				real mdt2 = 6 * m_dt * m_dt * m_;
+				real sdt2 = 6 * s_dt * s_dt * s_;
+
+				real r = 4.0767416621f * l - 3.3077115913f * m + 0.2309699292f * s - 1;
+				real r1 = 4.0767416621f * ldt - 3.3077115913f * mdt + 0.2309699292f * sdt;
+				real r2 = 4.0767416621f * ldt2 - 3.3077115913f * mdt2 + 0.2309699292f * sdt2;
+
+				real u_r = r1 / (r1 * r1 - 0.5f * r * r2);
+				real t_r = -r * u_r;
+
+				real g = -1.2684380046f * l + 2.6097574011f * m - 0.3413193965f * s - 1;
+				real g1 = -1.2684380046f * ldt + 2.6097574011f * mdt - 0.3413193965f * sdt;
+				real g2 = -1.2684380046f * ldt2 + 2.6097574011f * mdt2 - 0.3413193965f * sdt2;
+
+				real u_g = g1 / (g1 * g1 - 0.5f * g * g2);
+				real t_g = -g * u_g;
+
+				real b = -0.0041960863f * l - 0.7034186147f * m + 1.7076147010f * s - 1;
+				real b1 = -0.0041960863f * ldt - 0.7034186147f * mdt + 1.7076147010f * sdt;
+				real b2 = -0.0041960863f * ldt2 - 0.7034186147f * mdt2 + 1.7076147010f * sdt2;
+
+				real u_b = b1 / (b1 * b1 - 0.5f * b * b2);
+				real t_b = -b * u_b;
+
+				t_r = u_r >= 0.f ? t_r : FLT_MAX;
+				t_g = u_g >= 0.f ? t_g : FLT_MAX;
+				t_b = u_b >= 0.f ? t_b : FLT_MAX;
+
+				t += fmin(t_r, fmin(t_g, t_b));
+			}
+		}
+	}
+
+	return t;
+}
+real _toe(real x) {
+	const real k_1 = 0.206f; const real k_2 = 0.03f; const real k_3 = (1.f + k_1) / (1.f + k_2);
+	return 0.5f * (k_3 * x - k_1 + sqrt((k_3 * x - k_1) * (k_3 * x - k_1) + 4 * k_2 * k_3 * x));
+}
+real _toe_inv(real x) {
+	const real k_1 = 0.206f; const real k_2 = 0.03f; const real k_3 = (1.f + k_1) / (1.f + k_2);
+	return (x * x + k_1 * x) / (k_3 * (x + k_2));
+}
+void _to_ST(real cusp_L, real cusp_C, real* _s, real* _t) {
+	real L = cusp_L; real C = cusp_C;
+	*_s=C / L; *_t=C / (1 - L);
+}
+void _get_ST_mid(real a_, real b_, real *s,real *t){
+	*s = 0.11516993f + 1.f / (
+		+7.44778970f + 4.15901240f * b_
+		+ a_ * (-2.19557347f + 1.75198401f * b_
+			+ a_ * (-2.13704948f - 10.02301043f * b_
+				+ a_ * (-4.24894561f + 5.38770819f * b_ + 4.69891013f * a_
+					)))
+		);
+	*t = 0.11239642f + 1.f / (
+		+1.61320320f - 0.68124379f * b_
+		+ a_ * (+0.40370612f + 0.90148123f * b_
+			+ a_ * (-0.27087943f + 0.61223990f * b_
+				+ a_ * (+0.00299215f - 0.45399568f * b_ - 0.14661872f * a_
+					)))
+		);
+}
+void _get_Cs(real L, real a_, real b_,real *rC_0, real *rC_mid, real *rC_max){
+	real cusp_L,cusp_C; _find_cusp(a_, b_,&cusp_L,&cusp_C);
+
+	real C_max = _find_gamut_intersection(a_, b_, L, 1, L,cusp_L,cusp_C);
+	real _S,_T; _to_ST(cusp_L,cusp_C,&_S, &_T);
+	real k = C_max / fmin((L * _S), (1 - L) * _T);
+	real C_mid;{
+		real _s, _t; _get_ST_mid(a_, b_,&_s,&_t);
+		real C_a = L * _s; real C_b = (1.f - L) * _t;
+		C_mid = 0.9f * k * sqrt(sqrt(1.f / (1.f / (C_a * C_a * C_a * C_a) + 1.f / (C_b * C_b * C_b * C_b))));
+	}
+
+	real C_0;{
+		real C_a = L * 0.4f;
+		real C_b = (1.f - L) * 0.8f;
+		C_0 = sqrt(1.f / (1.f / (C_a * C_a) + 1.f / (C_b * C_b)));
+	}
 
-    luma = weights[0] * rgb[0] + weights[1] * rgb[1] + weights[2] * rgb[2];
-    chroma = rgb[ix[2]] - rgb[ix[0]];
+	*rC_0=C_0; *rC_mid=C_mid; *rC_max=C_max;
+}
+void tnsHCY2RGB(real *hcy, real *rgb){
+	real h = hcy[0]; real s = hcy[1]; real l = hcy[2];
+
+	if (l >= 1.0f){ tnsVectorSet3(rgb,1,1,1); return; }
+	else if (l <= 0.0f){ tnsVectorSet3(rgb,0,0,0); return; }
 
-    if (chroma >= DBL_EPSILON){
-        X = (rgb[ix[1]] - rgb[ix[0]]) / chroma;
+	real a_ = cos(2.f * TNS_PI * h);
+	real b_ = sin(2.f * TNS_PI * h);
+	real L = _toe_inv(l);
 
-        Y_peak = weights[ix[2]] + X * weights[ix[1]];
-        if (luma != 0. && luma != 1.) chroma /= luma < Y_peak ? luma / Y_peak : (1. - luma) / (1. - Y_peak);
+	real C_0, C_mid, C_max;
+    _get_Cs(L, a_, b_,&C_0,&C_mid,&C_max);
 
-        hue = (H_sec + t * X) / 6.;
-    }else
-        chroma = hue = 0.0;
+	real mid = 0.8f; real mid_inv = 1.25f;
+	real C, t, k_0, k_1, k_2;
 
-    hcy[0] = hue;
-    hcy[1] = chroma;
-    hcy[2] = luma;
+	if (s < mid){
+		t = mid_inv * s;
+		k_1 = mid * C_0;
+		k_2 = (1.f - k_1 / C_mid);
+		C = t * k_1 / (1.f - k_2 * t);
+	}else{
+		t = (s - mid)/ (1 - mid);
+		k_0 = C_mid;
+		k_1 = (1.f - mid) * C_mid * C_mid * mid_inv * mid_inv / C_0;
+		k_2 = (1.f - (k_1) / (C_max - C_mid));
+		C = k_0 + t * k_1 / (1.f - k_2 * t);
+	}
+
+    real okl[3]={L, C * a_, C * b_};
+	tnsOKLAB2RGB(okl, rgb);
+    rgb[0]=_srgb_transfer_function(rgb[0]);
+    rgb[1]=_srgb_transfer_function(rgb[1]);
+    rgb[2]=_srgb_transfer_function(rgb[2]);
+}
+void tnsRGB2HCY(real *rgb, real *hcy){
+	real lab[3]; real lrgb[3];
+    lrgb[0]=_srgb_transfer_function_inv(rgb[0]);
+    lrgb[1]=_srgb_transfer_function_inv(rgb[1]);
+    lrgb[2]=_srgb_transfer_function_inv(rgb[2]);
+    tnsRGB2OKLAB(lrgb,lab);
+
+    if(lab[0]>=1.0f-1e-4){ tnsVectorSet3(hcy,0,0,1); return; }
+    if(lab[0]<=1e-4){ tnsVectorSet3(hcy,0,0,0); return; }
+
+	real C = sqrt(lab[1]*lab[1] + lab[2]*lab[2]);
+	real a_ = (!C)?0:(lab[1] / C);
+	real b_ = (!C)?0:(lab[2] / C);
+
+	real L = lab[0];
+	real h = 0.5f + 0.5f * atan2(-lab[2], -lab[1]) / TNS_PI;
+
+	real C_0, C_mid, C_max;
+    _get_Cs(L, a_, b_,&C_0,&C_mid,&C_max);
+
+	real mid = 0.8f; real mid_inv = 1.25f;
+
+	real s;
+	if (C < C_mid){
+		real k_1 = mid * C_0;
+		real k_2 = (1.f - k_1 / C_mid);
+		real t = C / (k_1 + k_2 * C);
+		s = t * mid;
+	}else{
+		real k_0 = C_mid;
+		real k_1 = (1.f - mid) * C_mid * C_mid * mid_inv * mid_inv / C_0;
+		real k_2 = (1.f - (k_1) / (C_max - C_mid));
+		real t = (C - k_0) / (k_1 + k_2 * (C - k_0));
+		s = mid + (1.f - mid) * t;
+	}
+
+	real l = _toe(L);
+	hcy[0]=h; hcy[1]=s; hcy[2]=l;
 }
 
 void tnsClearAll(){
@@ -4070,7 +4205,7 @@ void tnsMakeQuad4d(real *arr, real x1, real y1, real z1, real w1, real x2, real
     arr[14] = z4;
     arr[15] = w4;
 }
-void tnsMakeCircle2d(real *arr, int slices, real ctrX, real ctrY, real r){
+void tnsMakeCircle2d(real *arr, int slices, real ctrX, real ctrY, real r, int jump){
     int i;
     real radstep = 2 * TNS_PI / (real)slices;
     real rd = 0;
@@ -4078,8 +4213,9 @@ void tnsMakeCircle2d(real *arr, int slices, real ctrX, real ctrY, real r){
     for (i = 0; i < slices; i++){
         x = ctrX + cos(rd) * r;
         y = ctrY + sin(rd) * r;
-        arr[2 * i] = x;
-        arr[2 * i + 1] = y;
+        int idx=2 * i * (1+jump);
+        arr[idx] = x;
+        arr[idx+1] = y;
         rd += radstep;
     }
 }
@@ -4113,8 +4249,8 @@ void tnsMakeBridgedIndex(unsigned int *result, int num, int revert, int begin){
 }
 
 void tnsMakeRing2d(real *arr, int *index, int slices, real ctrX, real ctrY, real r1, real r2){
-    tnsMakeCircle2d(arr, slices, ctrX, ctrY, r1);
-    tnsMakeCircle2d(&arr[slices*2], slices, ctrX, ctrY, r2);
+    tnsMakeCircle2d(arr, slices, ctrX, ctrY, r1,0);
+    tnsMakeCircle2d(&arr[slices*2], slices, ctrX, ctrY, r2,0);
     tnsMakeBridgedIndex(index, slices, 0, 0);
     index[slices*2]=0; index[slices*2+1]=slices;
 }

la_util.c

@@ -1470,6 +1470,39 @@ int strDestroyStringSplitor(laStringSplitor **ss){
     return 1;
 }
 
+char * strSub(char *input, char *substring, char *replace){
+    int     number_of_matches = 0;
+    size_t  substring_size = strlen(substring), replace_size = strlen(replace), buffer_size;
+    char    *buffer, *bp, *ip;
+    if (substring_size){
+        ip = strstr(input, substring);
+        while (ip != NULL){
+            number_of_matches++;
+            ip = strstr(ip+substring_size, substring);
+        }
+    }
+    else number_of_matches = strlen (input) + 1;
+    buffer_size = strlen(input) + number_of_matches*(replace_size - substring_size) + 1;
+    if ((buffer = ((char *) malloc(buffer_size))) == NULL){
+        return NULL;
+    }
+    bp = buffer;
+    ip = strstr(input, substring);
+    while ((ip != NULL) && (*input != '\0')){
+        if (ip == input){
+            memcpy (bp, replace, replace_size+1);
+            bp += replace_size;
+            if (substring_size)input += substring_size;
+            else*(bp++) = *(input++);
+            ip = strstr(input, substring);
+        }
+        else while (input != ip) *(bp++) = *(input++);
+    }
+    if (substring_size)strcpy (bp, input);
+    else memcpy (bp, replace, replace_size+1);
+    return buffer;
+}
+
 char buff[128]={0};
 int strMakeInstructions(laStringSplitor **result, char *content){
     laStringPart *sp;

la_util.h

@@ -555,6 +555,8 @@ NEED_STRUCTURE(laSubProp);
 void memAssignRef(void* This, void** ptr, void* instance);
 void memAssignRefSafe(laSubProp* sp, void* This, void** ptr, void* instance);
 
+char * strSub(char *input, char *substring, char *replace);
+
 int strGetStringTerminateBy(char * content, char terminator, char * Out);
 int strHeadOfStringMatch(char * Str, char * SubStr);
 int strSkipSegmet(char ** pivot, char * content);

resources/la_tns_shaders.cpp

@@ -0,0 +1,642 @@
+#include "la_5.h"
+
+extern "C" const char* TNS_SHADER_COLOR_COMMON=R"(
+//okhsl by Björn Ottosson
+
+#define M_PI 3.1415926535897932384626433832795
+
+float cbrt( float x )
+{
+    return sign(x)*pow(abs(x),1.0f/3.0f);
+}
+
+float srgb_transfer_function(float a)
+{
+	return .0031308f >= a ? 12.92f * a : 1.055f * pow(a, .4166666666666667f) - .055f;
+}
+
+float srgb_transfer_function_inv(float a)
+{
+	return .04045f < a ? pow((a + .055f) / 1.055f, 2.4f) : a / 12.92f;
+}
+
+vec3 linear_srgb_to_oklab(vec3 c)
+{
+	float l = 0.4122214708f * c.r + 0.5363325363f * c.g + 0.0514459929f * c.b;
+	float m = 0.2119034982f * c.r + 0.6806995451f * c.g + 0.1073969566f * c.b;
+	float s = 0.0883024619f * c.r + 0.2817188376f * c.g + 0.6299787005f * c.b;
+
+	float l_ = cbrt(l);
+	float m_ = cbrt(m);
+	float s_ = cbrt(s);
+
+	return vec3(
+		0.2104542553f * l_ + 0.7936177850f * m_ - 0.0040720468f * s_,
+		1.9779984951f * l_ - 2.4285922050f * m_ + 0.4505937099f * s_,
+		0.0259040371f * l_ + 0.7827717662f * m_ - 0.8086757660f * s_
+	);
+}
+
+vec3 oklab_to_linear_srgb(vec3 c)
+{
+	float l_ = c.x + 0.3963377774f * c.y + 0.2158037573f * c.z;
+	float m_ = c.x - 0.1055613458f * c.y - 0.0638541728f * c.z;
+	float s_ = c.x - 0.0894841775f * c.y - 1.2914855480f * c.z;
+
+	float l = l_ * l_ * l_;
+	float m = m_ * m_ * m_;
+	float s = s_ * s_ * s_;
+
+	return vec3(
+		+4.0767416621f * l - 3.3077115913f * m + 0.2309699292f * s,
+		-1.2684380046f * l + 2.6097574011f * m - 0.3413193965f * s,
+		-0.0041960863f * l - 0.7034186147f * m + 1.7076147010f * s
+	);
+}
+
+// Finds the maximum saturation possible for a given hue that fits in sRGB
+// Saturation here is defined as S = C/L
+// a and b must be normalized so a^2 + b^2 == 1
+float compute_max_saturation(float a, float b)
+{
+	// Max saturation will be when one of r, g or b goes below zero.
+
+	// Select different coefficients depending on which component goes below zero first
+	float k0, k1, k2, k3, k4, wl, wm, ws;
+
+	if (-1.88170328f * a - 0.80936493f * b > 1.f)
+	{
+		// Red component
+		k0 = +1.19086277f; k1 = +1.76576728f; k2 = +0.59662641f; k3 = +0.75515197f; k4 = +0.56771245f;
+		wl = +4.0767416621f; wm = -3.3077115913f; ws = +0.2309699292f;
+	}
+	else if (1.81444104f * a - 1.19445276f * b > 1.f)
+	{
+		// Green component
+		k0 = +0.73956515f; k1 = -0.45954404f; k2 = +0.08285427f; k3 = +0.12541070f; k4 = +0.14503204f;
+		wl = -1.2684380046f; wm = +2.6097574011f; ws = -0.3413193965f;
+	}
+	else
+	{
+		// Blue component
+		k0 = +1.35733652f; k1 = -0.00915799f; k2 = -1.15130210f; k3 = -0.50559606f; k4 = +0.00692167f;
+		wl = -0.0041960863f; wm = -0.7034186147f; ws = +1.7076147010f;
+	}
+
+	// Approximate max saturation using a polynomial:
+	float S = k0 + k1 * a + k2 * b + k3 * a * a + k4 * a * b;
+
+	// Do one step Halley's method to get closer
+	// this gives an error less than 10e6, except for some blue hues where the dS/dh is close to infinite
+	// this should be sufficient for most applications, otherwise do two/three steps 
+
+	float k_l = +0.3963377774f * a + 0.2158037573f * b;
+	float k_m = -0.1055613458f * a - 0.0638541728f * b;
+	float k_s = -0.0894841775f * a - 1.2914855480f * b;
+
+	{
+		float l_ = 1.f + S * k_l;
+		float m_ = 1.f + S * k_m;
+		float s_ = 1.f + S * k_s;
+
+		float l = l_ * l_ * l_;
+		float m = m_ * m_ * m_;
+		float s = s_ * s_ * s_;
+
+		float l_dS = 3.f * k_l * l_ * l_;
+		float m_dS = 3.f * k_m * m_ * m_;
+		float s_dS = 3.f * k_s * s_ * s_;
+
+		float l_dS2 = 6.f * k_l * k_l * l_;
+		float m_dS2 = 6.f * k_m * k_m * m_;
+		float s_dS2 = 6.f * k_s * k_s * s_;
+
+		float f = wl * l + wm * m + ws * s;
+		float f1 = wl * l_dS + wm * m_dS + ws * s_dS;
+		float f2 = wl * l_dS2 + wm * m_dS2 + ws * s_dS2;
+
+		S = S - f * f1 / (f1 * f1 - 0.5f * f * f2);
+	}
+
+	return S;
+}
+
+// finds L_cusp and C_cusp for a given hue
+// a and b must be normalized so a^2 + b^2 == 1
+vec2 find_cusp(float a, float b)
+{
+	// First, find the maximum saturation (saturation S = C/L)
+	float S_cusp = compute_max_saturation(a, b);
+
+	// Convert to linear sRGB to find the first point where at least one of r,g or b >= 1:
+	vec3 rgb_at_max = oklab_to_linear_srgb(vec3( 1, S_cusp * a, S_cusp * b ));
+	float L_cusp = cbrt(1.f / max(max(rgb_at_max.r, rgb_at_max.g), rgb_at_max.b));
+	float C_cusp = L_cusp * S_cusp;
+
+	return vec2( L_cusp , C_cusp );
+}
+
+// Finds intersection of the line defined by 
+// L = L0 * (1 - t) + t * L1;
+// C = t * C1;
+// a and b must be normalized so a^2 + b^2 == 1
+float find_gamut_intersection(float a, float b, float L1, float C1, float L0, vec2 cusp)
+{
+	// Find the intersection for upper and lower half seprately
+	float t;
+	if (((L1 - L0) * cusp.y - (cusp.x - L0) * C1) <= 0.f)
+	{
+		// Lower half
+
+		t = cusp.y * L0 / (C1 * cusp.x + cusp.y * (L0 - L1));
+	}
+	else
+	{
+		// Upper half
+
+		// First intersect with triangle
+		t = cusp.y * (L0 - 1.f) / (C1 * (cusp.x - 1.f) + cusp.y * (L0 - L1));
+
+		// Then one step Halley's method
+		{
+			float dL = L1 - L0;
+			float dC = C1;
+
+			float k_l = +0.3963377774f * a + 0.2158037573f * b;
+			float k_m = -0.1055613458f * a - 0.0638541728f * b;
+			float k_s = -0.0894841775f * a - 1.2914855480f * b;
+
+			float l_dt = dL + dC * k_l;
+			float m_dt = dL + dC * k_m;
+			float s_dt = dL + dC * k_s;
+
+
+			// If higher accuracy is required, 2 or 3 iterations of the following block can be used:
+			{
+				float L = L0 * (1.f - t) + t * L1;
+				float C = t * C1;
+
+				float l_ = L + C * k_l;
+				float m_ = L + C * k_m;
+				float s_ = L + C * k_s;
+
+				float l = l_ * l_ * l_;
+				float m = m_ * m_ * m_;
+				float s = s_ * s_ * s_;
+
+				float ldt = 3.f * l_dt * l_ * l_;
+				float mdt = 3.f * m_dt * m_ * m_;
+				float sdt = 3.f * s_dt * s_ * s_;
+
+				float ldt2 = 6.f * l_dt * l_dt * l_;
+				float mdt2 = 6.f * m_dt * m_dt * m_;
+				float sdt2 = 6.f * s_dt * s_dt * s_;
+
+				float r = 4.0767416621f * l - 3.3077115913f * m + 0.2309699292f * s - 1.f;
+				float r1 = 4.0767416621f * ldt - 3.3077115913f * mdt + 0.2309699292f * sdt;
+				float r2 = 4.0767416621f * ldt2 - 3.3077115913f * mdt2 + 0.2309699292f * sdt2;
+
+				float u_r = r1 / (r1 * r1 - 0.5f * r * r2);
+				float t_r = -r * u_r;
+
+				float g = -1.2684380046f * l + 2.6097574011f * m - 0.3413193965f * s - 1.f;
+				float g1 = -1.2684380046f * ldt + 2.6097574011f * mdt - 0.3413193965f * sdt;
+				float g2 = -1.2684380046f * ldt2 + 2.6097574011f * mdt2 - 0.3413193965f * sdt2;
+
+				float u_g = g1 / (g1 * g1 - 0.5f * g * g2);
+				float t_g = -g * u_g;
+
+				float b = -0.0041960863f * l - 0.7034186147f * m + 1.7076147010f * s - 1.f;
+				float b1 = -0.0041960863f * ldt - 0.7034186147f * mdt + 1.7076147010f * sdt;
+				float b2 = -0.0041960863f * ldt2 - 0.7034186147f * mdt2 + 1.7076147010f * sdt2;
+
+				float u_b = b1 / (b1 * b1 - 0.5f * b * b2);
+				float t_b = -b * u_b;
+
+				t_r = u_r >= 0.f ? t_r : 10000.f;
+				t_g = u_g >= 0.f ? t_g : 10000.f;
+				t_b = u_b >= 0.f ? t_b : 10000.f;
+
+				t += min(t_r, min(t_g, t_b));
+			}
+		}
+	}
+
+	return t;
+}
+
+float find_gamut_intersection(float a, float b, float L1, float C1, float L0)
+{
+	// Find the cusp of the gamut triangle
+	vec2 cusp = find_cusp(a, b);
+
+	return find_gamut_intersection(a, b, L1, C1, L0, cusp);
+}
+
+vec3 gamut_clip_preserve_chroma(vec3 rgb)
+{
+	if (rgb.r < 1.f && rgb.g < 1.f && rgb.b < 1.f && rgb.r > 0.f && rgb.g > 0.f && rgb.b > 0.f)
+		return rgb;
+
+	vec3 lab = linear_srgb_to_oklab(rgb);
+
+	float L = lab.x;
+	float eps = 0.00001f;
+	float C = max(eps, sqrt(lab.y * lab.y + lab.z * lab.z));
+	float a_ = lab.y / C;
+	float b_ = lab.z / C;
+
+	float L0 = clamp(L, 0.f, 1.f);
+
+	float t = find_gamut_intersection(a_, b_, L, C, L0);
+	float L_clipped = L0 * (1.f - t) + t * L;
+	float C_clipped = t * C;
+
+	return oklab_to_linear_srgb(vec3( L_clipped, C_clipped * a_, C_clipped * b_ ));
+}
+
+vec3 gamut_clip_project_to_0_5(vec3 rgb)
+{
+	if (rgb.r < 1.f && rgb.g < 1.f && rgb.b < 1.f && rgb.r > 0.f && rgb.g > 0.f && rgb.b > 0.f)
+		return rgb;
+
+	vec3 lab = linear_srgb_to_oklab(rgb);
+
+	float L = lab.x;
+	float eps = 0.00001f;
+	float C = max(eps, sqrt(lab.y * lab.y + lab.z * lab.z));
+	float a_ = lab.y / C;
+	float b_ = lab.z / C;
+
+	float L0 = 0.5;
+
+	float t = find_gamut_intersection(a_, b_, L, C, L0);
+	float L_clipped = L0 * (1.f - t) + t * L;
+	float C_clipped = t * C;
+
+	return oklab_to_linear_srgb(vec3( L_clipped, C_clipped * a_, C_clipped * b_ ));
+}
+
+vec3 gamut_clip_project_to_L_cusp(vec3 rgb)
+{
+	if (rgb.r < 1.f && rgb.g < 1.f && rgb.b < 1.f && rgb.r > 0.f && rgb.g > 0.f && rgb.b > 0.f)
+		return rgb;
+
+	vec3 lab = linear_srgb_to_oklab(rgb);
+
+	float L = lab.x;
+	float eps = 0.00001f;
+	float C = max(eps, sqrt(lab.y * lab.y + lab.z * lab.z));
+	float a_ = lab.y / C;
+	float b_ = lab.z / C;
+
+	// The cusp is computed here and in find_gamut_intersection, an optimized solution would only compute it once.
+	vec2 cusp = find_cusp(a_, b_);
+
+	float L0 = cusp.x;
+
+	float t = find_gamut_intersection(a_, b_, L, C, L0);
+
+	float L_clipped = L0 * (1.f - t) + t * L;
+	float C_clipped = t * C;
+
+	return oklab_to_linear_srgb(vec3( L_clipped, C_clipped * a_, C_clipped * b_ ));
+}
+
+vec3 gamut_clip_adaptive_L0_0_5(vec3 rgb, float alpha)
+{
+	if (rgb.r < 1.f && rgb.g < 1.f && rgb.b < 1.f && rgb.r > 0.f && rgb.g > 0.f && rgb.b > 0.f)
+		return rgb;
+
+	vec3 lab = linear_srgb_to_oklab(rgb);
+
+	float L = lab.x;
+	float eps = 0.00001f;
+	float C = max(eps, sqrt(lab.y * lab.y + lab.z * lab.z));
+	float a_ = lab.y / C;
+	float b_ = lab.z / C;
+
+	float Ld = L - 0.5f;
+	float e1 = 0.5f + abs(Ld) + alpha * C;
+	float L0 = 0.5f * (1.f + sign(Ld) * (e1 - sqrt(e1 * e1 - 2.f * abs(Ld))));
+
+	float t = find_gamut_intersection(a_, b_, L, C, L0);
+	float L_clipped = L0 * (1.f - t) + t * L;
+	float C_clipped = t * C;
+
+	return oklab_to_linear_srgb(vec3( L_clipped, C_clipped * a_, C_clipped * b_ ));
+}
+
+vec3 gamut_clip_adaptive_L0_L_cusp(vec3 rgb, float alpha)
+{
+	if (rgb.r < 1.f && rgb.g < 1.f && rgb.b < 1.f && rgb.r > 0.f && rgb.g > 0.f && rgb.b > 0.f)
+		return rgb;
+
+	vec3 lab = linear_srgb_to_oklab(rgb);
+
+	float L = lab.x;
+	float eps = 0.00001f;
+	float C = max(eps, sqrt(lab.y * lab.y + lab.z * lab.z));
+	float a_ = lab.y / C;
+	float b_ = lab.z / C;
+
+	// The cusp is computed here and in find_gamut_intersection, an optimized solution would only compute it once.
+	vec2 cusp = find_cusp(a_, b_);
+
+	float Ld = L - cusp.x;
+	float k = 2.f * (Ld > 0.f ? 1.f - cusp.x : cusp.x);
+
+	float e1 = 0.5f * k + abs(Ld) + alpha * C / k;
+	float L0 = cusp.x + 0.5f * (sign(Ld) * (e1 - sqrt(e1 * e1 - 2.f * k * abs(Ld))));
+
+	float t = find_gamut_intersection(a_, b_, L, C, L0);
+	float L_clipped = L0 * (1.f - t) + t * L;
+	float C_clipped = t * C;
+
+	return oklab_to_linear_srgb(vec3( L_clipped, C_clipped * a_, C_clipped * b_ ));
+}
+
+float toe(float x)
+{
+	float k_1 = 0.206f;
+	float k_2 = 0.03f;
+	float k_3 = (1.f + k_1) / (1.f + k_2);
+	return 0.5f * (k_3 * x - k_1 + sqrt((k_3 * x - k_1) * (k_3 * x - k_1) + 4.f * k_2 * k_3 * x));
+}
+
+float toe_inv(float x)
+{
+	float k_1 = 0.206f;
+	float k_2 = 0.03f;
+	float k_3 = (1.f + k_1) / (1.f + k_2);
+	return (x * x + k_1 * x) / (k_3 * (x + k_2));
+}
+
+vec2 to_ST(vec2 cusp)
+{
+	float L = cusp.x;
+	float C = cusp.y;
+	return vec2( C / L, C / (1.f - L) );
+}
+
+// Returns a smooth approximation of the location of the cusp
+// This polynomial was created by an optimization process
+// It has been designed so that S_mid < S_max and T_mid < T_max
+vec2 get_ST_mid(float a_, float b_)
+{
+	float S = 0.11516993f + 1.f / (
+		+7.44778970f + 4.15901240f * b_
+		+ a_ * (-2.19557347f + 1.75198401f * b_
+			+ a_ * (-2.13704948f - 10.02301043f * b_
+				+ a_ * (-4.24894561f + 5.38770819f * b_ + 4.69891013f * a_
+					)))
+		);
+
+	float T = 0.11239642f + 1.f / (
+		+1.61320320f - 0.68124379f * b_
+		+ a_ * (+0.40370612f + 0.90148123f * b_
+			+ a_ * (-0.27087943f + 0.61223990f * b_
+				+ a_ * (+0.00299215f - 0.45399568f * b_ - 0.14661872f * a_
+					)))
+		);
+
+	return vec2( S, T );
+}
+
+vec3 get_Cs(float L, float a_, float b_)
+{
+	vec2 cusp = find_cusp(a_, b_);
+
+	float C_max = find_gamut_intersection(a_, b_, L, 1.f, L, cusp);
+	vec2 ST_max = to_ST(cusp);
+	
+	// Scale factor to compensate for the curved part of gamut shape:
+	float k = C_max / min((L * ST_max.x), (1.f - L) * ST_max.y);
+
+	float C_mid;
+	{
+		vec2 ST_mid = get_ST_mid(a_, b_);
+
+		// Use a soft minimum function, instead of a sharp triangle shape to get a smooth value for chroma.
+		float C_a = L * ST_mid.x;
+		float C_b = (1.f - L) * ST_mid.y;
+		C_mid = 0.9f * k * sqrt(sqrt(1.f / (1.f / (C_a * C_a * C_a * C_a) + 1.f / (C_b * C_b * C_b * C_b))));
+	}
+
+	float C_0;
+	{
+		// for C_0, the shape is independent of hue, so vec2 are constant. Values picked to roughly be the average values of vec2.
+		float C_a = L * 0.4f;
+		float C_b = (1.f - L) * 0.8f;
+
+		// Use a soft minimum function, instead of a sharp triangle shape to get a smooth value for chroma.
+		C_0 = sqrt(1.f / (1.f / (C_a * C_a) + 1.f / (C_b * C_b)));
+	}
+
+	return vec3( C_0, C_mid, C_max );
+}
+
+vec3 okhsl_to_srgb(vec3 hsl)
+{
+	float h = hsl.x;
+	float s = hsl.y;
+	float l = hsl.z;
+
+	if (l == 1.0f)
+	{
+		return vec3( 1.f, 1.f, 1.f );
+	}
+
+	else if (l == 0.f)
+	{
+		return vec3( 0.f, 0.f, 0.f );
+	}
+
+	float a_ = cos(2.f * M_PI * h);
+	float b_ = sin(2.f * M_PI * h);
+	float L = toe_inv(l);
+
+	vec3 cs = get_Cs(L, a_, b_);
+	float C_0 = cs.x;
+	float C_mid = cs.y;
+	float C_max = cs.z;
+
+	float mid = 0.8f;
+	float mid_inv = 1.25f;
+
+	float C, t, k_0, k_1, k_2;
+
+	if (s < mid)
+	{
+		t = mid_inv * s;
+
+		k_1 = mid * C_0;
+		k_2 = (1.f - k_1 / C_mid);
+
+		C = t * k_1 / (1.f - k_2 * t);
+	}
+	else
+	{
+		t = (s - mid)/ (1.f - mid);
+
+		k_0 = C_mid;
+		k_1 = (1.f - mid) * C_mid * C_mid * mid_inv * mid_inv / C_0;
+		k_2 = (1.f - (k_1) / (C_max - C_mid));
+
+		C = k_0 + t * k_1 / (1.f - k_2 * t);
+	}
+
+	vec3 rgb = oklab_to_linear_srgb(vec3( L, C * a_, C * b_ ));
+	return vec3(
+		srgb_transfer_function(rgb.r),
+		srgb_transfer_function(rgb.g),
+		srgb_transfer_function(rgb.b)
+	);
+}
+
+vec3 srgb_to_okhsl(vec3 rgb)
+{
+	vec3 lab = linear_srgb_to_oklab(vec3(
+		srgb_transfer_function_inv(rgb.r),
+		srgb_transfer_function_inv(rgb.g),
+		srgb_transfer_function_inv(rgb.b)
+		));
+
+	float C = sqrt(lab.y * lab.y + lab.z * lab.z);
+	float a_ = lab.y / C;
+	float b_ = lab.z / C;
+
+	float L = lab.x;
+	float h = 0.5f + 0.5f * atan(-lab.z, -lab.y) / M_PI;
+
+	vec3 cs = get_Cs(L, a_, b_);
+	float C_0 = cs.x;
+	float C_mid = cs.y;
+	float C_max = cs.z;
+
+	// Inverse of the interpolation in okhsl_to_srgb:
+
+	float mid = 0.8f;
+	float mid_inv = 1.25f;
+
+	float s;
+	if (C < C_mid)
+	{
+		float k_1 = mid * C_0;
+		float k_2 = (1.f - k_1 / C_mid);
+
+		float t = C / (k_1 + k_2 * C);
+		s = t * mid;
+	}
+	else
+	{
+		float k_0 = C_mid;
+		float k_1 = (1.f - mid) * C_mid * C_mid * mid_inv * mid_inv / C_0;
+		float k_2 = (1.f - (k_1) / (C_max - C_mid));
+
+		float t = (C - k_0) / (k_1 + k_2 * (C - k_0));
+		s = mid + (1.f - mid) * t;
+	}
+
+	float l = toe(L);
+	return vec3( h, s, l );
+}
+
+
+vec3 okhsv_to_srgb(vec3 hsv)
+{
+	float h = hsv.x;
+	float s = hsv.y;
+	float v = hsv.z;
+
+	float a_ = cos(2.f * M_PI * h);
+	float b_ = sin(2.f * M_PI * h);
+	
+	vec2 cusp = find_cusp(a_, b_);
+	vec2 ST_max = to_ST(cusp);
+	float S_max = ST_max.x;
+	float T_max = ST_max.y;
+	float S_0 = 0.5f;
+	float k = 1.f- S_0 / S_max;
+
+	// first we compute L and V as if the gamut is a perfect triangle:
+
+	// L, C when v==1:
+	float L_v = 1.f   - s * S_0 / (S_0 + T_max - T_max * k * s);
+	float C_v = s * T_max * S_0 / (S_0 + T_max - T_max * k * s);
+
+	float L = v * L_v;
+	float C = v * C_v;
+
+	// then we compensate for both toe and the curved top part of the triangle:
+	float L_vt = toe_inv(L_v);
+	float C_vt = C_v * L_vt / L_v;
+
+	float L_new = toe_inv(L);
+	C = C * L_new / L;
+	L = L_new;
+
+	vec3 rgb_scale = oklab_to_linear_srgb(vec3( L_vt, a_ * C_vt, b_ * C_vt ));
+	float scale_L = cbrt(1.f / max(max(rgb_scale.r, rgb_scale.g), max(rgb_scale.b, 0.f)));
+
+	L = L * scale_L;
+	C = C * scale_L;
+
+	vec3 rgb = oklab_to_linear_srgb(vec3( L, C * a_, C * b_ ));
+	return vec3(
+		srgb_transfer_function(rgb.r),
+		srgb_transfer_function(rgb.g),
+		srgb_transfer_function(rgb.b)
+	);
+}
+
+vec3 srgb_to_okhsv(vec3 rgb)
+{
+	vec3 lab = linear_srgb_to_oklab(vec3(
+		srgb_transfer_function_inv(rgb.r),
+		srgb_transfer_function_inv(rgb.g),
+		srgb_transfer_function_inv(rgb.b)
+		));
+
+	float C = sqrt(lab.y * lab.y + lab.z * lab.z);
+	float a_ = lab.y / C;
+	float b_ = lab.z / C;
+
+	float L = lab.x;
+	float h = 0.5f + 0.5f * atan(-lab.z, -lab.y) / M_PI;
+
+	vec2 cusp = find_cusp(a_, b_);
+	vec2 ST_max = to_ST(cusp);
+	float S_max = ST_max.x;
+	float T_max = ST_max.y;
+	float S_0 = 0.5f;
+	float k = 1.f - S_0 / S_max;
+
+	// first we find L_v, C_v, L_vt and C_vt
+
+	float t = T_max / (C + L * T_max);
+	float L_v = t * L;
+	float C_v = t * C;
+
+	float L_vt = toe_inv(L_v);
+	float C_vt = C_v * L_vt / L_v;
+
+	// we can then use these to invert the step that compensates for the toe and the curved top part of the triangle:
+	vec3 rgb_scale = oklab_to_linear_srgb(vec3( L_vt, a_ * C_vt, b_ * C_vt ));
+	float scale_L = cbrt(1.f / max(max(rgb_scale.r, rgb_scale.g), max(rgb_scale.b, 0.f)));
+
+	L = L / scale_L;
+	C = C / scale_L;
+
+	C = C * toe(L) / L;
+	L = toe(L);
+
+	// we can now compute v and s:
+
+	float v = L / L_v;
+	float s = (S_0 + T_max) * C_v / ((T_max * S_0) + T_max * k * C_v);
+
+	return vec3 (h, s, v );
+}
+
+)";

resources/la_widgets.c

@@ -1,6 +1,7 @@
 #include "../la_5.h"
 
 extern LA MAIN;
+extern tnsMain* T;
 
 laWidget _LA_WIDGET_FIXED_GROUP={0};
 laWidget _LA_WIDGET_TAB={0};
@@ -666,7 +667,6 @@ void la_FloatArrayColorDraw(laUiItem *ui, int h){
     int Len, i, Y = ui->U;
 
     laGetFloatArray(&ui->PP, Data);
-    tnsLogToLinear(Data, MAIN.Gamma);
     Len = laGetArrayLength(&ui->PP);
 
     tnsUseNoTexture();
@@ -1041,8 +1041,8 @@ void la_ColorCircleDrawHCY(laUiItem *ui, int h){
     ;
     real r = (ui->B - ui->U - bt->TP - bt->BP) / 2;
     int i = 0;
-    real colors[296]; //4*74
-    real verts[148];
+    real colors[584]={0}; //4*72*2+4*2
+    real verts[292]={0}; //72*2*2+2*2
     real hcy[3] = {0, 1, 1};
     real step = 1.0 / 72.0f;
     real RealColor[4] = {0};
@@ -1053,60 +1053,50 @@ void la_ColorCircleDrawHCY(laUiItem *ui, int h){
 
     laGetFloatArray(&ui->PP, RealColor);
 
-    if (MAIN.ColorAccessCorrectGamma) {
-        tnsLogToLinear(RealColor, MAIN.Gamma);
-    }
-
-    tnsRGBtoHCY(RealColor, hcy);
-
-    //if (MAIN.ColorAccessCorrectGamma) {
-    //    tnsSingleLinearToLog(&hcy[2], MAIN.Gamma);
-    //}
-
-    //tnsSingleLinearToLog(&hcy[1], 2.2);
+    tnsRGB2HCY(RealColor, hcy);
 
     PickerPos[0] = c + cos(hcy[0] * TNS_PI * 2) * hcy[1] * r;
     PickerPos[1] = ui->U + r + sin(hcy[0] * TNS_PI * 2) * hcy[1] * r;
 
-    hcy[1] = 1;
     hcy[0] = 0;
+    hcy[1] = 1;
 
     for (i; i < 72; i += 1){
-        int beg = 4 + i * 4;
-        hcy[0] += step;
-        tnsHCYtoRGB(hcy, &colors[beg]);
-        //tnsLinearToLog(&colors[beg], MAIN.Gamma);
-        colors[beg + 3] = 1;
+        int beg = i * 8;
+        hcy[0]+=step; tnsVectorSet3v(&colors[beg],hcy); colors[beg+3]=1;
+        tnsVectorSet4v(&colors[beg+4],&colors[beg]); colors[beg+5]=0;
     }
-    
+
+    tnsFlush();
+
     tnsUseNoTexture();
-    colors[0] = colors[1] = colors[2] = hcy[2];
-    colors[3] = 1;
-    colors[292] = colors[4];
-    colors[293] = colors[5];
-    colors[294] = colors[6];
-    colors[295] = colors[7];
-    tnsColorArray4d(colors, 74);
-    tnsMakeCircle2d(&verts[2], 72, c, ui->U + r, r);
-    verts[0] = c;
-    verts[1] = ui->U + r;
-    verts[146] = verts[2];
-    verts[147] = verts[3];
-    tnsVertexArray2d(verts, 74);
-    tnsPackAs(GL_TRIANGLE_FAN);
+    tnsVectorSet4(&colors[576],1,1,hcy[2],1);
+    tnsVectorSet4(&colors[580],1,0,hcy[2],1);
+    tnsColorArray4d(colors, 146);
+    tnsMakeCircle2d(verts, 72, c, ui->U + r, r, 1);
+    for(int i=0;i<73;i++){ tnsVectorSet2(&verts[2+i*4],c,ui->U + r); }
+    tnsVectorSet4v(&verts[288],&verts[0]);
+    tnsVectorSet4v(&verts[290],&verts[2]);
+    tnsVertexArray2d(verts, 146);
+    tnsPackAs(GL_TRIANGLE_STRIP);
+
+    tnsUniformColorMode(T->immShader,1);
+    tnsFlush();
+    tnsUniformColorMode(T->immShader,0);
 
     tnsColor4dv(laThemeColor(bt,LA_BT_BORDER));
-    tnsVertexArray2d(&verts[4], 72);
+    tnsMakeCircle2d(verts, 72, c, ui->U + r, r, 0);
+    tnsVertexArray2d(verts, 72);
     tnsPackAs(GL_LINE_LOOP);
 
     tnsColor4dv(RealColor);
-    tnsMakeCircle2d(verts, 16, PickerPos[0], PickerPos[1], 8);
+    tnsMakeCircle2d(verts, 16, PickerPos[0], PickerPos[1], 8,0);
     tnsVertexArray2d(verts, 16);
     tnsPackAs(GL_TRIANGLE_FAN);
     tnsColor4d(1, 1, 1, 1);
     tnsVertexArray2d(verts, 16);
     tnsPackAs(GL_LINE_LOOP);
-    tnsMakeCircle2d(verts, 16, PickerPos[0], PickerPos[1], 7);
+    tnsMakeCircle2d(verts, 16, PickerPos[0], PickerPos[1], 7,0);
     tnsColor4d(0.1, 0.1, 0.1, 1);
     tnsVertexArray2d(verts, 16);
     tnsPackAs(GL_LINE_LOOP);
@@ -1397,7 +1387,7 @@ void la_ValueMeter2DDraw(laUiItem *ui, int h){
     tnsPackAs(GL_LINES);
 
     real circle[48];
-    tnsMakeCircle2d(circle,24,CL,CU,LA_RH2);
+    tnsMakeCircle2d(circle,24,CL,CU,LA_RH2,0);
     tnsVertexArray2d(circle,24);
     tnsPackAs(GL_LINE_LOOP);
 
@@ -2015,8 +2005,7 @@ int OPMOD_ColorHCY(laOperator *a, laEvent *e){
 
     if (e->Type & LA_MOUSE_EVENT && es->Dragging){
         laGetFloatArray(&ui->PP, Color);
-        tnsLogToLinear(Color, MAIN.Gamma);
-        tnsRGBtoHCY(Color, hcy);
+        tnsRGB2HCY(Color, hcy);
         if (es->Dragging==1){
             abso = fabs(atan((real)dy / (real)dx));
             hcy[0] = abso / TNS_PI / 2;
@@ -2030,20 +2019,11 @@ int OPMOD_ColorHCY(laOperator *a, laEvent *e){
                 }
             }
             hcy[1] = dist / r; TNS_CLAMP(hcy[1],0,1);
-            //printf("hcy[1] = %d -> ",hcy[1]);
-            //if (MAIN.ColorAccessCorrectGamma) {
-            //tnsSingleLogToLinear(&hcy[1], 2.2);
-            //}
-            //printf("%d\n", hcy[1]);
         }else if (dist < r + LA_RH * 2 && dx > 0){
             abso = -atan((real)dy / (real)dx) / TNS_PI * 2 + 0.5;
             hcy[2] = abso; TNS_CLAMP(hcy[2],0,1);
-            //if (MAIN.ColorAccessCorrectGamma) {
-            //    tnsSingleLogToLinear(&hcy[2], MAIN.Gamma);
-            //}
         }
-        tnsHCYtoRGB(hcy, Color);
-        tnsLinearToLog(Color, MAIN.Gamma);
+        tnsHCY2RGB(hcy, Color);
         laSetFloatArrayAllArray(&ui->PP, Color);
         laRedrawCurrentPanel();
         return LA_RUNNING;