Adding generic FindComponentByName to configurer API, got CaptureCompare working on 2 simultaneous sources

Author: CaiB

ColorChord.NET-API/ColorChordAPI.cs

@@ -6,7 +6,7 @@ public static class ColorChordAPI
 {
     /// <summary>Use this version as return value for <see cref="Extensions.IExtension.APIVersion"/> in your extension.</summary>
     /// <remarks>This allows ColorChord.NET to know if the installed version of your extension is compatible.</remarks>
-    public const uint APIVersion = 22;
+    public const uint APIVersion = 23;
 
     public static IConfigurer Configurer;
 }

ColorChord.NET-API/Config/IConfigurer.cs

@@ -53,4 +53,10 @@ public interface IConfigurer
     /// <param name="config">The config section of a component which needs to find a controller, the <see cref="ConfigNames.CONTROLLER_NAME"/> key will be used to find it by name.</param>
     /// <returns>The controller instance if it was found, null otherwise.</returns>
     public Controller? FindController(Dictionary<string, object> config);
+
+    /// <summary>Finds a specific component by its name. More specific methods of this interface should be preferred in most cases.</summary>
+    /// <param name="componentType">The type of component to find</param>
+    /// <param name="componentName">The "Name" parameter of that component to search for, ignored in the case of <see cref="Component.Source"/> or <see cref="Component.NoteFinder"/> if there is only 1 loaded of that type.</param>
+    /// <returns>THe component if found, null otherwise</returns>
+    public object? FindComponentByName(Component componentType, string componentName);
 }

ColorChord.NET/Config/Configurer.cs

@@ -25,6 +25,7 @@ public sealed class ConfigurerInst : IConfigurer
     public IVisualizer? FindVisualizer(IOutput target, Dictionary<string, object> config, Type acceptableFormat) => Configurer.FindVisualizer(target, config, acceptableFormat);
     public IOutput? FindOutput(Dictionary<string, object> config) => Configurer.FindOutput(config);
     public Controller? FindController(Dictionary<string, object> config) => Configurer.FindController(config);
+    public object? FindComponentByName(Component componentType, string componentName) => Configurer.FindComponentByName(componentType, componentName);
 }
 
 public static class Configurer
@@ -262,6 +263,44 @@ public static bool Configure(object targetObj, Dictionary<string, object> config
         return Controller;
     }
 
+    /// <summary>Finds a specific component by its name. More specific methods of this interface should be preferred in most cases.</summary>
+    /// <param name="componentType">The type of component to find</param>
+    /// <param name="componentName">The "Name" parameter of that component to search for, ignored in the case of <see cref="Component.Source"/> or <see cref="Component.NoteFinder"/> if there is only 1 loaded of that type.</param>
+    /// <returns>THe component if found, null otherwise</returns>
+    public static object? FindComponentByName(Component componentType, string componentName)
+    {
+        if (componentType == Component.Source)
+        {
+            IAudioSource? Source;
+            if (ColorChord.SourceInsts.Count == 1) { Source = ColorChord.SourceInsts.First().Value; }
+            else { ColorChord.SourceInsts.TryGetValue(componentName, out Source); }
+            return Source;
+        }
+        else if (componentType == Component.NoteFinder)
+        {
+            NoteFinderCommon? NoteFinder;
+            if (ColorChord.NoteFinderInsts.Count == 1) { NoteFinder = ColorChord.NoteFinderInsts.First().Value; }
+            else { ColorChord.NoteFinderInsts.TryGetValue(componentName, out NoteFinder); }
+            return NoteFinder;
+        }
+        else if (componentType == Component.Visualizers)
+        {
+            ColorChord.VisualizerInsts.TryGetValue(componentName, out IVisualizer? Visualizer);
+            return Visualizer;
+        }
+        else if (componentType == Component.Outputs)
+        {
+            ColorChord.OutputInsts.TryGetValue(componentName, out IOutput? Output);
+            return Output;
+        }
+        else if (componentType == Component.Controllers)
+        {
+            ColorChord.ControllerInsts.TryGetValue(componentName, out Controller? Controller);
+            return Controller;
+        }
+        return null;
+    }
+
     /// <summary>Checks the config to see if a reasonable value is provided, otherwise uses the default and outputs a warning.</summary>
     /// <param name="config">The configuration to read from.</param>
     /// <param name="fltAttr">The attribute on the item to configure.</param>

ColorChord.NET/Outputs/Display/CaptureCompare.cs

@@ -1,21 +1,25 @@
 using ColorChord.NET.API;
+using ColorChord.NET.API.Config;
 using ColorChord.NET.API.Outputs.Display;
 using ColorChord.NET.API.Visualizers;
 using ColorChord.NET.API.Visualizers.Formats;
+using ColorChord.NET.Config;
 using OpenTK.Graphics.OpenGL4;
 using OpenTK.Mathematics;
 using OpenTK.Windowing.Common;
 using OpenTK.Windowing.GraphicsLibraryFramework;
 using System;
+using System.Collections.Generic;
 
 namespace ColorChord.NET.Outputs.Display;
 
-public class CaptureCompare : IDisplayMode
+public class CaptureCompare : IDisplayMode, IConfigurableAttr
 {
     private readonly DisplayOpenGL HostWindow;
     private readonly IDiscrete1D DataSourceA, DataSourceB;
 
-    private const int TEX_HEIGHT = 128;
+    [ConfigInt("HistoryLength", 16, 16384, 768)]
+    private int TextureHeight = 768;
 
     private Shader? Shader;
 
@@ -44,11 +48,17 @@ public class CaptureCompare : IDisplayMode
        -1F,  1F, 0F, 0F
     };
 
-    public CaptureCompare(DisplayOpenGL parent, IVisualizer visualizer)
+    public CaptureCompare(DisplayOpenGL parent, IVisualizer visualizer, Dictionary<string, object> config)
     {
         this.HostWindow = parent;
         this.DataSourceA = visualizer as IDiscrete1D ?? throw new Exception($"{nameof(CaptureCompare)} cannot use the provided visualizer, as it doesn't support {nameof(IDiscrete1D)} output mode.");
-        this.DataSourceB = this.DataSourceA; // TODO: Actually read the second one
+        
+        IDiscrete1D? DataSourceBTemp = null;
+        if (config.TryGetValue("SecondaryVisualizer", out object? SecondVizNameObj) && SecondVizNameObj is string SecondVizName) { DataSourceBTemp = Configurer.FindComponentByName(Component.Visualizers, SecondVizName) as IDiscrete1D; }
+        if (DataSourceBTemp == null) { Log.Warn($"{nameof(CaptureCompare)} could not find the secondary visualizer, and is instead using the primary one for both inputs. You may set it using \"SecondaryVisualizer\"."); }
+        this.DataSourceB = DataSourceBTemp ?? this.DataSourceA;
+        config.Remove("SecondaryVisualizer");
+        Configurer.Configure(this, config);
     }
 
     public void Load()
@@ -67,37 +77,37 @@ public void Load()
         this.TextureHandleCaptureB = GL.GenTexture();
         this.TextureWidthA = this.DataSourceA.GetCountDiscrete();
         this.TextureWidthB = this.DataSourceB.GetCountDiscrete();
-        this.NewTextureDataA = new uint[this.TextureWidthA * TEX_HEIGHT];
-        this.NewTextureDataB = new uint[this.TextureWidthB * TEX_HEIGHT];
+        this.NewTextureDataA = new uint[this.TextureWidthA * TextureHeight];
+        this.NewTextureDataB = new uint[this.TextureWidthB * TextureHeight];
 
         // Activate texture
         GL.ActiveTexture(TextureUnit.Texture0);
         GL.BindTexture(TextureTarget.Texture2D, this.TextureHandleA);
-        GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, this.TextureWidthA, TEX_HEIGHT, 0, PixelFormat.Rgba, PixelType.UnsignedByte, this.NewTextureDataA);
+        GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, this.TextureWidthA, TextureHeight, 0, PixelFormat.Rgba, PixelType.UnsignedByte, this.NewTextureDataA);
         GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Nearest);
         GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMinFilter.Nearest);
         GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat);
         GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat);
 
         GL.ActiveTexture(TextureUnit.Texture1);
         GL.BindTexture(TextureTarget.Texture2D, this.TextureHandleB);
-        GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, this.TextureWidthB, TEX_HEIGHT, 0, PixelFormat.Rgba, PixelType.UnsignedByte, this.NewTextureDataB);
+        GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, this.TextureWidthB, TextureHeight, 0, PixelFormat.Rgba, PixelType.UnsignedByte, this.NewTextureDataB);
         GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Nearest);
         GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMinFilter.Nearest);
         GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat);
         GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat);
 
         GL.ActiveTexture(TextureUnit.Texture2);
         GL.BindTexture(TextureTarget.Texture2D, this.TextureHandleCaptureA);
-        GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, this.TextureWidthA, TEX_HEIGHT, 0, PixelFormat.Rgba, PixelType.UnsignedByte, this.NewTextureDataA);
+        GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, this.TextureWidthA, TextureHeight, 0, PixelFormat.Rgba, PixelType.UnsignedByte, this.NewTextureDataA);
         GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Nearest);
         GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMinFilter.Nearest);
         GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat);
         GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat);
 
         GL.ActiveTexture(TextureUnit.Texture3);
         GL.BindTexture(TextureTarget.Texture2D, this.TextureHandleCaptureB);
-        GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, this.TextureWidthB, TEX_HEIGHT, 0, PixelFormat.Rgba, PixelType.UnsignedByte, this.NewTextureDataB);
+        GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, this.TextureWidthB, TextureHeight, 0, PixelFormat.Rgba, PixelType.UnsignedByte, this.NewTextureDataB);
         GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Nearest);
         GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMinFilter.Nearest);
         GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat);
@@ -139,17 +149,28 @@ public void Load()
     public void Dispatch()
     {
         if (!this.SetupDone) { return; }
-        bool IsFromA = true;
-        IDiscrete1D Source = IsFromA ? this.DataSourceA : this.DataSourceB;
 
-        int Count = Source.GetCountDiscrete();
-        uint[] Data = Source.GetDataDiscrete();
-        if (PopulatedTextureLocA == TEX_HEIGHT - 1) { return; } // Drop this data, we are too behind
-        lock (NewTextureDataA)
         {
-            Array.Copy(Data, 0, NewTextureDataA, PopulatedTextureLocA * TextureWidthA, Count);
-            PopulatedTextureLocA++;
+            int Count = this.DataSourceA.GetCountDiscrete();
+            uint[] Data = this.DataSourceA.GetDataDiscrete();
+            if (this.PopulatedTextureLocA >= TextureHeight - 1) { return; } // Drop this data, we are too behind
+            lock (this.NewTextureDataA)
+            {
+                Array.Copy(Data, 0, this.NewTextureDataA, this.PopulatedTextureLocA * TextureWidthA, Count);
+                this.PopulatedTextureLocA++;
+            }
         }
+        {
+            int Count = this.DataSourceB.GetCountDiscrete();
+            uint[] Data = this.DataSourceB.GetDataDiscrete();
+            if (this.PopulatedTextureLocB >= TextureHeight - 1) { return; } // Drop this data, we are too behind
+            lock (this.NewTextureDataB)
+            {
+                Array.Copy(Data, 0, this.NewTextureDataB, this.PopulatedTextureLocB * TextureWidthB, Count);
+                this.PopulatedTextureLocB++;
+            }
+        }
+
         this.NewData = true;
     }
 
@@ -163,30 +184,57 @@ public void Render()
             if (this.PopulatedTextureLocA != 0)
             {
                 GL.ActiveTexture(TextureUnit.Texture0);
-                lock (NewTextureDataA)
+                lock (this.NewTextureDataA)
                 {
-                    GL.TexSubImage2D(TextureTarget.Texture2D, 0, 0, this.UploadedTextureLocA, this.TextureWidthA, this.PopulatedTextureLocA, PixelFormat.Rgba, PixelType.UnsignedByte, this.NewTextureDataA);
-                    this.UploadedTextureLocA = (this.UploadedTextureLocA + this.PopulatedTextureLocA) % TEX_HEIGHT;
-                    GL.Uniform1(this.LocationAdvanceALive, (float)this.UploadedTextureLocA / TEX_HEIGHT);
+                    if (this.UploadedTextureLocA + this.PopulatedTextureLocA < TextureHeight)
+                    {
+                        GL.TexSubImage2D(TextureTarget.Texture2D, 0, 0, this.UploadedTextureLocA, this.TextureWidthA, this.PopulatedTextureLocA, PixelFormat.Rgba, PixelType.UnsignedByte, this.NewTextureDataA);
+                    }
+                    else
+                    {
+                        int BottomCount = TextureHeight - this.UploadedTextureLocA;
+                        int TopCount = this.PopulatedTextureLocA - BottomCount;
+                        GL.TexSubImage2D(TextureTarget.Texture2D, 0, 0, this.UploadedTextureLocA, this.TextureWidthA, BottomCount, PixelFormat.Rgba, PixelType.UnsignedByte, this.NewTextureDataA);
+                        GL.TexSubImage2D(TextureTarget.Texture2D, 0, 0, 0, this.TextureWidthA, TopCount, PixelFormat.Rgba, PixelType.UnsignedByte, ref this.NewTextureDataA[this.TextureWidthA * BottomCount]);
+                    }
+                    this.UploadedTextureLocA = (this.UploadedTextureLocA + this.PopulatedTextureLocA) % TextureHeight;
+                    GL.Uniform1(this.LocationAdvanceALive, (float)this.UploadedTextureLocA / TextureHeight);
                     this.PopulatedTextureLocA = 0;
                 }
             }
             if (this.PopulatedTextureLocB != 0)
             {
-
+                GL.ActiveTexture(TextureUnit.Texture1);
+                lock (this.NewTextureDataB)
+                {
+                    if (this.UploadedTextureLocB + this.PopulatedTextureLocB < TextureHeight)
+                    {
+                        GL.TexSubImage2D(TextureTarget.Texture2D, 0, 0, this.UploadedTextureLocB, this.TextureWidthB, this.PopulatedTextureLocB, PixelFormat.Rgba, PixelType.UnsignedByte, this.NewTextureDataB);
+                    }
+                    else
+                    {
+                        int BottomCount = TextureHeight - this.UploadedTextureLocB;
+                        int TopCount = this.PopulatedTextureLocB - BottomCount;
+                        GL.TexSubImage2D(TextureTarget.Texture2D, 0, 0, this.UploadedTextureLocB, this.TextureWidthB, BottomCount, PixelFormat.Rgba, PixelType.UnsignedByte, this.NewTextureDataB);
+                        GL.TexSubImage2D(TextureTarget.Texture2D, 0, 0, 0, this.TextureWidthB, TopCount, PixelFormat.Rgba, PixelType.UnsignedByte, ref this.NewTextureDataB[this.TextureWidthB * BottomCount]);
+                    }
+                    this.UploadedTextureLocB = (this.UploadedTextureLocB + this.PopulatedTextureLocB) % TextureHeight;
+                    GL.Uniform1(this.LocationAdvanceBLive, (float)this.UploadedTextureLocB / TextureHeight);
+                    this.PopulatedTextureLocB = 0;
+                }
             }
         }
 
         if (this.DoCaptureA)
         {
-            GL.CopyImageSubData(this.TextureHandleA, ImageTarget.Texture2D, 0, 0, 0, 0, this.TextureHandleCaptureA, ImageTarget.Texture2D, 0, 0, 0, 0, this.TextureWidthA, TEX_HEIGHT, 1);
-            GL.Uniform1(this.LocationAdvanceACapture, (float)this.UploadedTextureLocA / TEX_HEIGHT);
+            GL.CopyImageSubData(this.TextureHandleA, ImageTarget.Texture2D, 0, 0, 0, 0, this.TextureHandleCaptureA, ImageTarget.Texture2D, 0, 0, 0, 0, this.TextureWidthA, TextureHeight, 1);
+            GL.Uniform1(this.LocationAdvanceACapture, (float)this.UploadedTextureLocA / TextureHeight);
             this.DoCaptureA = false;
         }
         if (this.DoCaptureB)
         {
-            GL.CopyImageSubData(this.TextureHandleA, ImageTarget.Texture2D, 0, 0, 0, 0, this.TextureHandleCaptureB, ImageTarget.Texture2D, 0, 0, 0, 0, this.TextureWidthA, TEX_HEIGHT, 1);
-            GL.Uniform1(this.LocationAdvanceBCapture, (float)this.UploadedTextureLocA / TEX_HEIGHT);
+            GL.CopyImageSubData(this.TextureHandleB, ImageTarget.Texture2D, 0, 0, 0, 0, this.TextureHandleCaptureB, ImageTarget.Texture2D, 0, 0, 0, 0, this.TextureWidthB, TextureHeight, 1);
+            GL.Uniform1(this.LocationAdvanceBCapture, (float)this.UploadedTextureLocB / TextureHeight);
             this.DoCaptureB = false;
         }
 

ColorChord.NET/Outputs/Display/Shaders/CaptureCompare.frag

@@ -50,11 +50,13 @@ void main()
     {
         if (TexCoord.y < 0.5) // A
         {
+            //                                                 1.0~0.5           0.5~1.0  -      0        0.5        -                         * 
             TextureColour = texture(TextureUnitALive, (vec2(1.0 - TexCoord.y, TexCoord.x) - vec2(0.0, HorizontalSplit - (AdvanceALive / 2.0))) * vec2(2.0, 1.0 / (1.0 - HorizontalSplit)));
         }
         else // B
         {
-            TextureColour = texture(TextureUnitBLive, (TexCoord - vec2(HorizontalSplit, 0.5)) * vec2(1.0 / (1.0 - HorizontalSplit), 2.0));
+            //                                                 
+            TextureColour = texture(TextureUnitBLive, (vec2(1.0 - TexCoord.y, TexCoord.x) - vec2(0.5, HorizontalSplit - (AdvanceALive / 2.0))) * vec2(2.0, 1.0 / (1.0 - HorizontalSplit)));
         }
     }
 

ColorChord.NET/Visualizers/NoteFinderPassthrough.cs

@@ -40,7 +40,7 @@ public void GetData()
     {
         ReadOnlySpan<float> RawData = this.NoteFinder.AllBinValues;
         if (this.Data.Length != RawData.Length) { this.Data = new uint[RawData.Length]; }
-        for (int i = 0; i < RawData.Length; i++) { this.Data[i] = VisualizerTools.CCToRGB((i % 24) / 24F, 1F, MathF.Pow(RawData[i] * 4.5F, 2F)); }
+        for (int i = 0; i < RawData.Length; i++) { this.Data[i] = VisualizerTools.CCToRGB((float)i / this.NoteFinder.BinsPerOctave, 1F, MathF.Pow(RawData[i] * 4.5F, 2F)); }
         foreach (IOutput Out in this.Outputs) { Out.Dispatch(); }
     }