void ConvexFillScanline(int x, int y, bool goUp, bool goDown)
    {
        int minEcks = x;
        int maxEcks = x;

        while (minEcks > 0 && ShouldBeThisColour(minEcks - 1, y))
        {
            minEcks--;
        }

        while (maxEcks < Width - 1 && ShouldBeThisColour(maxEcks + 1, y))
        {
            maxEcks++;
        }

        int firstPixel = y * Width + minEcks;
        int lastPixel = y * Width + maxEcks;

        for (int pix = firstPixel; pix <= lastPixel; pix++)
        {
            Pixels[pix] = thisColour;
        }

        if (goUp && y > 0)
        {
            int nextY = y - 1;
            for (x = minEcks; x <= maxEcks; x++)
            {
                if (ShouldBeThisColour(x, nextY))
                {
                    ConvexFillScanline(x, nextY, true, false);
                    // once you've found a point 'up' you can stop looking because it'll all be 
                    // filled by the scanline,
                    // because the shape is convex.
                    break;
                }
            }
        }

        if (goDown && y < Height - 1)
        {
            int NextY = y + 1;
            for (x = minEcks; x <= maxEcks; x++)
            {
                if (ShouldBeThisColour(x, NextY))
                {
                    ConvexFillScanline(x, NextY, false, true);
                }
            }
        }

    }

    private bool ShouldBeThisColour(int x, int y)
    {
        Vertex centerVert = verts[currentVSiteID];
        // see if current tile is closer to any other
        // of the adjacent sites, if it is than we 
        // break/continue
        float dstToCenter =
            Vector2.Distance(new Vector2(x, y),
                             new Vector2((float)centerVert.x, (float)centerVert.y));

        foreach (int sideID in adjacentSiteIDs)
        {
            Vertex VertToCheck = verts[sideID];

            float dstToAdjacent =
                Vector2.Distance(new Vector2(x, y),
                                 new Vector2((float)VertToCheck.x, (float)VertToCheck.y));

            if (dstToAdjacent < dstToCenter)
            {
                return false;
            }
        }

        return true;
    }

Raenir Salazar fucked around with this message at 08:21 on Sep 29, 2020

Raenir Salazar fucked around with this message at 06:45 on Oct 6, 2020

TIP fucked around with this message at 21:57 on Oct 6, 2020

    private void SetUniqueVoronoiColours(int totalPoints)
    {
        for (int i = 0; i < totalPoints; i++)
        {
            // get a colour
            Color m_colour = GetColour(i);

            VCellColours[i] = m_colour;

        }
    }

Raenir Salazar fucked around with this message at 03:39 on Oct 10, 2020

int numColours = (this is your input value);
int numShades = (int)(power(numColours, 1/3)+1);  // Cube root + 1 means numShades*numShades*numShades is more than enough to fill your array.
Color getColor(int index) {
  float red = (index % numShades) / (float)(numShades - 1);
  float green = ((int)(index / numShades) % numShades) / (float)(numShades - 1);
  float blue = ((int)(index / numShades / numShades) % numShades) / (float)(numShades - 1);
  return new Color(red, green, blue);
}

roomforthetuna fucked around with this message at 03:57 on Oct 10, 2020

Raenir Salazar fucked around with this message at 05:16 on Oct 10, 2020

(int min, int max) hueRange, satRange, valRange;
hueRange = (1, 360);
satRange = (0, 255);
valRange = (0, 255);
// This will generate 1000 colors (10*10*10).  To set (approximate) number of colors directly, use cubic root of n for each.
int hueCount = 10; // Number of hues to generate. Must be greater than 1 to avoid a div/0 error.
int satCount = 10; // Number of saturation bands to generate.  Must be greater than 1 to avoid a div/0 error.
int valCount = 10; // Number of value bands to generate.  Must be greater than 1 to avoid a div/0 error.
// I recommend introducing some randomness in the generation so you don't end up with a TOO obviously generated result
float hueJitter = 0.05f;
float satJitter = 0.05f;
float valJitter = 0.05f;
var colors = new List<ColorHSV>();

for (var i = 0; i < hueCount; i++) {
    for (var j = 0; j < satCount; j++) {
        for (var k = 0; k < valCount; k++) {
            var hue = Math.Lerp(hueRange.min, hueRange.max, ((float)i / (hueCount - 1)) + Random.Range(-hueJitter, hueJitter));
            var sat = Math.Lerp(satRange.min, satRange.max, ((float)j / (satCount - 1)) + Random.Range(-satJitter, satJitter));
            var val = Math.Lerp(valRange.min, valRange.max, ((float)k / (valCount - 1)) + Random.Range(-valJitter, valJitter)); //This gives a fully linear distribution, however people don't see brightness linearly.  Recommend using gamma scaling instead.  This is left as an exercise to the reader :)
            colors.add(new ColorHSV(hue, sat, val));
        }
    }
}

KillHour fucked around with this message at 05:25 on Oct 10, 2020