il y a 1 mois · d70e5f7b4c
--- a/Editor/index.html
+++ b/Editor/index.html
@@ -152,6 +152,11 @@
 
				                                     <span class="lbl">Enabled</span>
			
 
				                                     <label class="switch"><input type="checkbox" id="lutEnabled" checked><span class="track"></span></label>
			
 
				                                 </div>
			
 
				+                                <div class="wb-row toggle-row">
			
 
				+                                    <span class="lbl">Log input</span>
			
 
				+                                    <label class="switch"><input type="checkbox" id="lutLogInput"><span class="track"></span></label>
			
 
				+                                </div>
			
 
				+                                <div class="lut-hint">Turn on for F-Log / S-Log / V-Log &rarr; display conversion LUTs so they look as intended on a normal photo.</div>
			
 
				                                 <div class="slider" data-key="lutAmount" data-min="0" data-max="100" data-def="100" data-step="1"><span class="s-name">Amount</span><span class="s-track"><input type="range"></span><input class="s-val" type="number"></div>
			
 
				                                 <div class="group-reset"><button class="link-btn" id="btnClearLut">Remove LUT</button></div>
			
 
				                             </div>
			
--- a/Editor/js/editor.js
+++ b/Editor/js/editor.js
@@ -27,6 +27,7 @@
 
				     state.baseTemp = 5500;
			
 
				     state.treatment = "color";
			
 
				     state.lutEnabled = true;
			
 
				+    state.lutLogInput = false;
			
 
				     // Per-group bypass ("eye") toggles.
			
 
				     state.groupOn = { light: true, color: true, effects: true, lut: true };
			
 
				 
			
@@ -136,7 +137,8 @@
 
				             grain: g.effects ? state.grain : 0,
			
 
				             // LUT group
			
 
				             lutEnabled: !!(lut && state.lutEnabled && g.lut),
			
 
				-            lutAmount: state.lutAmount / 100
			
 
				+            lutAmount: state.lutAmount / 100,
			
 
				+            lutLogInput: state.lutLogInput
			
 
				         };
			
 
				         if (state.treatment === "bw") { p.saturation = -100; p.vibrance = 0; }
			
 
				         return p;
			
@@ -466,6 +468,12 @@
 
				         if (g) { g.classList.remove("bypassed"); }
			
 
				         state.groupOn.lut = true;
			
 
				         document.getElementById("lutEnabled").checked = true;
			
 
				+        // Auto-enable "Log input" for log->display conversion LUTs (F-Log, S-Log,
			
 
				+        // V-Log, Log-C, C-Log ...), which expect a flat log signal.
			
 
				+        var tag = ((parsed.title || "") + " " + (displayName || "")).toLowerCase();
			
 
				+        var isLog = /(^|[^a-z])(f-?log|s-?log|v-?log|log-?c|c-?log|n-?log|d-?log|z-?log|log3|rec709|to_rec|to709|_log|log_)/.test(tag) || tag.indexOf("log") >= 0;
			
 
				+        state.lutLogInput = isLog;
			
 
				+        document.getElementById("lutLogInput").checked = isLog;
			
 
				         document.getElementById("lutInfo").style.display = "block";
			
 
				         document.getElementById("lutName").textContent = (parsed.title ? parsed.title + "  " : "") + displayName + "  (" + parsed.size + "³)";
			
 
				         scheduleRender();
			
@@ -562,6 +570,10 @@
 
				         state.lutEnabled = this.checked;
			
 
				         scheduleRender();
			
 
				     });
			
 
				+    document.getElementById("lutLogInput").addEventListener("change", function () {
			
 
				+        state.lutLogInput = this.checked;
			
 
				+        scheduleRender();
			
 
				+    });
			
 
				     document.getElementById("btnClearLut").addEventListener("click", function () {
			
 
				         lut = null;
			
 
				         renderer.setLUT(null);
			
--- a/Editor/js/glrender.js
+++ b/Editor/js/glrender.js
@@ -72,9 +72,31 @@ const GLRender = (function () {
 
				     uniform float uLutSize;
			
 
				     uniform vec3  uLutDomainMin;
			
 
				     uniform vec3  uLutDomainMax;
			
 
				+    uniform int   uLutLogInput;
			
 
				 
			
 
				     const vec3 LUMA = vec3(0.2126, 0.7152, 0.0722);
			
 
				 
			
 
				+    // sRGB EOTF (display -> scene linear); inverse of toDisplay().
			
 
				+    vec3 toLinear(vec3 c){
			
 
				+        vec3 lo = c / 12.92;
			
 
				+        vec3 hi = pow((c + 0.055) / 1.055, vec3(2.4));
			
 
				+        return mix(lo, hi, step(vec3(0.04045), c));
			
 
				+    }
			
 
				+
			
 
				+    // Log-flatten for feeding "log -> display" conversion LUTs from an already
			
 
				+    // display-referred image. A true camera log curve (F-Log/S-Log) assumes ~14
			
 
				+    // stops of scene-linear; a display JPEG has ~2.5, so a real log encode either
			
 
				+    // fogs the shadows or greys the highlights. Instead we use a clean log2
			
 
				+    // flatten that maps 0->0 and 1->1 (blacks stay black, whites stay white) but
			
 
				+    // lifts the mid-tones, giving the LUT the low-contrast signal it expects
			
 
				+    // without the wash-out. LOG_STOPS controls how flat.
			
 
				+    vec3 linearToFLog(vec3 lin){
			
 
				+        const float LOG_STOPS = 6.0;
			
 
				+        float k = exp2(LOG_STOPS) - 1.0;
			
 
				+        vec3 x = max(lin, vec3(0.0));
			
 
				+        return log2(1.0 + x * k) / LOG_STOPS;
			
 
				+    }
			
 
				+
			
 
				     // True sRGB OETF — matches how LUTs (and Photoshop) expect their input, and
			
 
				     // exactly inverts the sRGB decode applied to 8-bit source images on load.
			
 
				     vec3 toDisplay(vec3 c){
			
@@ -182,7 +204,12 @@ const GLRender = (function () {
 
				 
			
 
				         // 9. 3D LUT colour grade (tetrahedral, domain-mapped).
			
 
				         if (uLutEnabled == 1){
			
 
				-            vec3 dom = (clamp(v, 0.0, 1.0) - uLutDomainMin) / max(uLutDomainMax - uLutDomainMin, vec3(1e-5));
			
 
				+            vec3 lutIn = clamp(v, 0.0, 1.0);
			
 
				+            // For "log to display" LUTs, feed the flat log signal they expect.
			
 
				+            if (uLutLogInput == 1){
			
 
				+                lutIn = clamp(linearToFLog(toLinear(lutIn)), 0.0, 1.0);
			
 
				+            }
			
 
				+            vec3 dom = (lutIn - uLutDomainMin) / max(uLutDomainMax - uLutDomainMin, vec3(1e-5));
			
 
				             vec3 graded = lutTetra(clamp(dom, 0.0, 1.0));
			
 
				             v = mix(v, graded, uLutAmount);
			
 
				         }
			
@@ -448,6 +475,7 @@ const GLRender = (function () {
 
				             gl.uniform1i(u("uLutEnabled"), 1);
			
 
				             gl.uniform1f(u("uLutAmount"), p.lutAmount != null ? p.lutAmount : 1.0);
			
 
				             gl.uniform1f(u("uLutSize"), this.lutSize);
			
 
				+            gl.uniform1i(u("uLutLogInput"), p.lutLogInput ? 1 : 0);
			
 
				             var dmin = this.lutDomainMin || [0, 0, 0], dmax = this.lutDomainMax || [1, 1, 1];
			
 
				             gl.uniform3f(u("uLutDomainMin"), dmin[0], dmin[1], dmin[2]);
			
 
				             gl.uniform3f(u("uLutDomainMax"), dmax[0], dmax[1], dmax[2]);
			
@@ -455,6 +483,7 @@ const GLRender = (function () {
 
				             gl.bindTexture(gl.TEXTURE_3D, this.dummyLut);
			
 
				             gl.uniform1i(u("uLutEnabled"), 0);
			
 
				             gl.uniform1f(u("uLutSize"), 2.0);
			
 
				+            gl.uniform1i(u("uLutLogInput"), 0);
			
 
				             gl.uniform3f(u("uLutDomainMin"), 0, 0, 0);
			
 
				             gl.uniform3f(u("uLutDomainMax"), 1, 1, 1);
			
 
				         }