Crlf/lf consistency

Added palette reverse. Tried to make encoding and line endings consistent.

Author: behreajj

Clr.cs

@@ -458,8 +458,8 @@ public static bool Contains (in Clr c, in float v)
     /// <returns>the evaluation</returns>
     public static bool EqAlphaSatArith (in Clr a, in Clr b)
     {
-        return (int) (0.5f + Utils.Clamp (a.a, 0.0f, 1.0f) * 0xff) ==
-            (int) (0.5f + Utils.Clamp (b.a, 0.0f, 1.0f) * 0xff);
+        return (int) (0.5f + Utils.Clamp (a._a, 0.0f, 1.0f) * 0xff) ==
+            (int) (0.5f + Utils.Clamp (b._a, 0.0f, 1.0f) * 0xff);
     }
 
     /// <summary>
@@ -471,12 +471,12 @@ public static bool EqAlphaSatArith (in Clr a, in Clr b)
     /// <returns>the evaluation</returns>
     public static bool EqRgbSatArith (in Clr a, in Clr b)
     {
-        return (int) (0.5f + Utils.Clamp (a.b, 0.0f, 1.0f) * 0xff) ==
-            (int) (0.5f + Utils.Clamp (b.b, 0.0f, 1.0f) * 0xff) &&
-            (int) (0.5f + Utils.Clamp (a.g, 0.0f, 1.0f) * 0xff) ==
-            (int) (0.5f + Utils.Clamp (b.g, 0.0f, 1.0f) * 0xff) &&
-            (int) (0.5f + Utils.Clamp (a.r, 0.0f, 1.0f) * 0xff) ==
-            (int) (0.5f + Utils.Clamp (b.r, 0.0f, 1.0f) * 0xff);
+        return (int) (0.5f + Utils.Clamp (a._b, 0.0f, 1.0f) * 0xff) ==
+            (int) (0.5f + Utils.Clamp (b._b, 0.0f, 1.0f) * 0xff) &&
+            (int) (0.5f + Utils.Clamp (a._g, 0.0f, 1.0f) * 0xff) ==
+            (int) (0.5f + Utils.Clamp (b._g, 0.0f, 1.0f) * 0xff) &&
+            (int) (0.5f + Utils.Clamp (a._r, 0.0f, 1.0f) * 0xff) ==
+            (int) (0.5f + Utils.Clamp (b._r, 0.0f, 1.0f) * 0xff);
     }
 
     /// <summary>

ClrGradient.cs

@@ -356,7 +356,7 @@ protected int BisectRight (in float step)
         int high = this.keys.Count;
         while (low < high)
         {
-            // The | 0 is floor div?
+            // The | 0 is floor div.
             int middle = (low + high) / 2 | 0;
             if (step < this.keys[middle].Step)
                 high = middle;

Palette.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Text;
 
@@ -495,10 +494,13 @@ public string Name
     /// <param name="author">author</param>
     public Palette (in string name = "Palette", in string author = "Anonymous")
     {
-        // TODO: Implement a Palette.Tag inner class which has a name
+        // TODO: Consider a Palette.Tag inner class which has a name
         // and an int[] array which references indices in the palette.
         // Each palete will have a list/array of tags, which allow the
         // user to cluster together a palette into arbitrary groups.
+        // Problem is that it will be a challenge to keep tag indices
+        // up-to-date when the palette changes, entries are removed, etc.
+        // Maybe use a list of Entries, since they are classes.
         this.Name = name;
         this.Author = author;
     }
@@ -694,6 +696,54 @@ public static Palette Concat (in Palette a, in Palette b, in Palette target)
         return target;
     }
 
+    /// <summary>
+    /// Reverses the source palette.
+    /// </summary>
+    /// <param name="source">source palette</param>
+    /// <param name="target">target palette</param>
+    /// <returns>reversed palette</returns>
+    public static Palette Reverse (in Palette source, in Palette target)
+    {
+        return Palette.Reverse (source, 0, source.entries.Length, target);
+    }
+
+    /// <summary>
+    /// Reverses a subset of the source palette.
+    /// </summary>
+    /// <param name="source">source palette</param>
+    /// <param name="index">start index</param>
+    /// <param name="length">sample length</param>
+    /// <param name="target">target palette</param>
+    /// <returns>reversed palette</returns>
+    public static Palette Reverse (in Palette source, in int index, in int length, in Palette target)
+    {
+        Entry[ ] sourceEntries = source.entries;
+        int sourceLen = sourceEntries.Length;
+
+        Entry[ ] reversedEntries = new Entry[sourceLen];
+        System.Array.Copy (sourceEntries, 0, reversedEntries, 0, sourceLen);
+
+        int valIdx = Utils.Mod (index, sourceLen);
+        int valLen = Utils.Clamp (length, 1, sourceLen);
+        System.Array.Reverse (reversedEntries, valIdx, valLen);
+
+        if (Object.ReferenceEquals (source, target))
+        {
+            target.entries = reversedEntries;
+        }
+        else
+        {
+            target.entries = Entry.Resize (target.entries, sourceLen);
+            for (int i = 0; i < sourceLen; ++i)
+            {
+                Entry reversed = reversedEntries[i];
+                target.entries[i].Set (reversed.Color, reversed.Name);
+            }
+        }
+
+        return target;
+    }
+
     /// <summary>
     /// Returns a palette with three primary colors -- red, green and blue --
     /// and three secondary colors -- yellow, cyan and magenta -- in the
@@ -721,20 +771,19 @@ public static Palette Rgb (in Palette target)
     /// Returns a subset of a palette.
     /// </summary>
     /// <param name="source">source palette</param>
-    /// <param name="startIndex">start count</param>
-    /// <param name="count">sample count</param>
+    /// <param name="index">start index</param>
+    /// <param name="length">sample length</param>
     /// <param name="target">target palette</param>
     /// <returns>subset</returns>
-    public static Palette Subset (in Palette source, in int startIndex, in int count, in Palette target)
+    public static Palette Subset (in Palette source, in int index, in int length, in Palette target)
     {
-        int valCount = Utils.Max (1, count);
-
         Entry[ ] sourceEntries = source.entries;
-        Entry[ ] subsetEntries = new Entry[valCount];
-        int srcLen = sourceEntries.Length;
-        for (int i = 0; i < valCount; ++i)
+        int sourceLen = sourceEntries.Length;
+        int valLen = Utils.Clamp (length, 1, sourceLen);
+        Entry[ ] subsetEntries = new Entry[valLen];
+        for (int i = 0; i < valLen; ++i)
         {
-            int k = Utils.Mod (startIndex + i, srcLen);
+            int k = Utils.Mod (index + i, sourceLen);
             subsetEntries[i] = sourceEntries[k];
         }
 
@@ -744,8 +793,8 @@ public static Palette Subset (in Palette source, in int startIndex, in int count
         }
         else
         {
-            target.entries = Entry.Resize (target.entries, valCount);
-            for (int i = 0; i < valCount; ++i)
+            target.entries = Entry.Resize (target.entries, valLen);
+            for (int i = 0; i < valLen; ++i)
             {
                 Entry subsetEntry = subsetEntries[i];
                 target.entries[i].Set (subsetEntry.Color, subsetEntry.Name);

PolyType.cs

@@ -1,4 +1,4 @@
-/// <summary>
+/// <summary>
 /// The polygon type to be used when constructing new meshes.
 /// </summary>
 public enum PolyType : int