public override UnityEngine.Color GetColour(double x, double y)
{
UnityEngine.Color col1 = SourceModule.GetColour(x, y);
float brightnessChange = (float)BrightnessModule.GetValue(x, y);
// Read hsl:
float h = col1.r;
float s = col1.g;
float l = col1.b;
HslRgb.ToHsl(ref h, ref s, ref l);
// Boost brightness:
l *= 1f + brightnessChange;
// Back to colour:
HslRgb.ToRgb(ref h, ref s, ref l);
// Now RGB:
col1.r = h;
col1.g = s;
col1.b = l;
return(col1);
}
public override double GetValue(double t)
{
// Get control (0-1):
double control = ControlModule.GetValue(t);
int count = Sources.Length - 1;
if (count == 0)
{
return(control);
}
else if (count == 1)
{
return(Sources[1].GetValue(t));
}
// Reduce count (such that it ranges from 0->count-1):
count--;
// Map to being relative to the points:
control *= (double)count;
int index = (int)control;
if (index < 0)
{
// Sample it:
return(Sources[1].GetValue(t));
}
else if (index >= count)
{
// Sample there:
return(Sources[count + 1].GetValue(t));
}
else
{
// Make relative:
control -= (double)index;
}
// Control is now 0-1 relative to Points[index].
// Get current:
TextureNode current = Sources[index + 1];
if (control == 0)
{
// Just read it:
return(current.GetValue(t));
}
// Note that index is never equal to (actual count-1), therefore next is just:
TextureNode next = Sources[index + 2];
// Blend:
double a = current.GetValue(t);
double b = next.GetValue(t);
return(a + ((b - a) * control));
}
public override UnityEngine.Color GetColour(double x, double y)
{
UnityEngine.Color col1 = SourceModule.GetColour(x, y);
float hueChange = (float)HueModule.GetValue(x, y);
float satChange = (float)SatModule.GetValue(x, y);
float lumChange = (float)LumModule.GetValue(x, y);
// Read hsl:
float h = col1.r;
float s = col1.g;
float l = col1.b;
HslRgb.ToHsl(ref h, ref s, ref l);
// Boost all 3:
h = (h + hueChange) % 1f;
s *= 1f + satChange;
l *= 1f + lumChange;
// Back to colour:
HslRgb.ToRgb(ref h, ref s, ref l);
// Now RGB:
col1.r = h;
col1.g = s;
col1.b = l;
return(col1);
}
public override UnityEngine.Color GetColour(double x, double y)
{
UnityEngine.Color col1 = SourceModule.GetColour(x, y);
float hueChange = (float)HueModule.GetValue(x, y);
// Read hsl:
float h = col1.r;
float s = col1.g;
float l = col1.b;
HslRgb.ToHsl(ref h, ref s, ref l);
// Cycle the hue:
h = (h + hueChange) % 1f;
// Back to colour:
HslRgb.ToRgb(ref h, ref s, ref l);
// Now RGB:
col1.r = h;
col1.g = s;
col1.b = l;
return(col1);
}
public override UnityEngine.Color GetColour(double x, double y)
{
UnityEngine.Color col1 = SourceModule.GetColour(x, y);
float satChange = (float)SaturationModule.GetValue(x, y);
// Read hsl:
float h = col1.r;
float s = col1.g;
float l = col1.b;
HslRgb.ToHsl(ref h, ref s, ref l);
// Boost sat:
s *= (1f + satChange);
// Back to colour:
HslRgb.ToRgb(ref h, ref s, ref l);
// Now RGB:
col1.r = h;
col1.g = s;
col1.b = l;
return(col1);
}
public override UnityEngine.Color GetColour(double x, double y)
{
// Read coords:
double lookX = (XModule == null)?0:XModule.GetValue(x, y);
double lookY = (YModule == null)?0:YModule.GetValue(x, y);
// Read colour:
return(SourceModule.GetColour(lookX, lookY));
}
public override UnityEngine.Color GetColour(double x, double y)
{
// Read colour:
UnityEngine.Color col1 = SourceModule.GetColour(x, y);
// Read and apply alpha:
col1.a = (float)AlphaModule.GetValue(x, y);
return(col1);
}
public override double GetValue(double x, double y, double z)
{
double toNearest = ToNearestModule.GetValue(x, y, z);
if (toNearest == 0)
{
return(0);
}
return(toNearest * System.Math.Floor(SourceModule.GetValue(x, y, z) / toNearest));
}
public override double GetValue(double x, double y, double z)
{
double deg = DegreeModule.GetValue(x, y, z);
if (deg == 0)
{
return(0);
}
return(System.Math.Pow(SourceModule.GetValue(x, y, z), 1.0 / deg));
}
public override UnityEngine.Color GetColour(double x, double y)
{
UnityEngine.Color col1 = SourceModule.GetColour(x, y);
float ctrast = 1f + (float)LuminanceModule.GetValue(x, y);
// Boost:
col1.r *= ctrast;
col1.g *= ctrast;
col1.b *= ctrast;
return(col1);
}
public override UnityEngine.Color GetColour(double x, double y)
{
UnityEngine.Color col1 = SourceModule.GetColour(x, y);
float contrast = 1f + (float)ContrastModule.GetValue(x, y);
// Boost:
col1.r = ((col1.r - 0.5f) * contrast) + 0.5f;
col1.g = ((col1.g - 0.5f) * contrast) + 0.5f;
col1.b = ((col1.b - 0.5f) * contrast) + 0.5f;
return(col1);
}
public override UnityEngine.Color GetColour(double x, double y)
{
UnityEngine.Color col1 = SourceModule.GetColour(x, y);
float contrast = 1f + (float)Contrast.GetValue(x, y);
float origin = (float)Origin.GetValue(x, y);
// Boost:
col1.r = ((col1.r - origin) * contrast) + origin;
col1.g = ((col1.g - origin) * contrast) + origin;
col1.b = ((col1.b - origin) * contrast) + origin;
return(col1);
}
public override UnityEngine.Color GetColour(double x, double y)
{
// Read R:
float r = (float)RedModule.GetValue(x, y);
// Read G:
float g = (float)GreenModule.GetValue(x, y);
// Read B:
float b = (float)BlueModule.GetValue(x, y);
return(new Color(r, g, b, 1f));
}
public override UnityEngine.Color GetColour(double x, double y)
{
// Get the bounds:
double minX = MinXModule.GetValue(x, y);
double rangeX = RangeXModule.GetValue(x, y); // maxX = rangeX-minX
double minY = MinYModule.GetValue(x, y);
double rangeY = RangeYModule.GetValue(x, y); // maxY = rangeY-minY
//Wrap and clip both:
x = ((x - minX) % rangeX) + minX;
y = ((y - minY) % rangeY) + minY;
return(SourceModule.GetColour(x, y));
}
public override double GetValue(double x, double y, double z)
{
// Read value:
double value = SourceModule.GetValue(x, y, z);
// Read min of range:
double min = BlackModule.GetValue(x, y, z);
// Divide by range:
value /= (WhiteModule.GetValue(x, y, z) - min);
// Offset:
return(value + min);
}
public override void Prepare(DrawInfo info)
{
double xAngle = XAngle.GetValue(0, 0);
double yAngle = YAngle.GetValue(0, 0);
double zAngle = ZAngle.GetValue(0, 0);
double xCos, yCos, zCos, xSin, ySin, zSin;
xCos = System.Math.Cos(xAngle);
yCos = System.Math.Cos(yAngle);
zCos = System.Math.Cos(zAngle);
xSin = System.Math.Sin(xAngle);
ySin = System.Math.Sin(yAngle);
zSin = System.Math.Sin(zAngle);
Matrix = new double[4];
Matrix[0] = ySin * xSin * zSin + yCos * zCos;
Matrix[1] = xCos * zSin;
Matrix[2] = ySin * xSin * zCos - yCos * zSin;
Matrix[3] = xCos * zCos;
// Prepare sources:
base.Prepare(info);
}
public override UnityEngine.Color GetColour(double x, double y)
{
// 2 points (horizontal line), rotated clockwise by Angle.
// Length of the line is a constant.
// Sample those two points, then simply compute the difference.
// Read angle:
double angle = AngleModule.GetValue(x, y);
float sA = (float)System.Math.Sin(angle);
float cA = (float)System.Math.Cos(angle);
// Base points (rotate first)
float rightX = cA * HalfLine;
float rightY = sA * HalfLine;
// Read colour:
UnityEngine.Color col1 = SourceModule.GetColour(x - rightX, y - rightY);
// Read colour:
UnityEngine.Color col2 = SourceModule.GetColour(x + rightX, y + rightY);
// Difference divided by distance:
col1.r = (col2.r - col1.r) / LineLength;
col1.g = (col2.g - col1.g) / LineLength;
col1.b = (col2.b - col1.b) / LineLength;
return(col1);
}
public override UnityEngine.Color GetColour(double x, double y)
{
// Read H:
float h = (float)HueModule.GetValue(x, y);
// Read S:
float s = (float)SaturationModule.GetValue(x, y);
// Read L:
float l = (float)LumModule.GetValue(x, y);
// Convert to RGB:
HslRgb.ToRgb(ref h, ref s, ref l);
// Now RGB.
return(new Color(h, s, l, 1f));
}
public override UnityEngine.Color GetColour(double x, double y)
{
// Read colour:
UnityEngine.Color col1 = SourceModule.GetColour(x, y);
// Read gamma:
double gamma = GammaModule.GetValue(x, y);
// Map gamma into the 0.1 to 10 range, and invert it:
gamma = 1.0 / System.Math.Pow(10.0, gamma);
col1.r = (float)(col1.r * gamma);
col1.g = (float)(col1.g * gamma);
col1.b = (float)(col1.b * gamma);
return(col1);
}
public override UnityEngine.Color GetColour(double x, double y)
{
// Read L:
float l = (float)LightModule.GetValue(x, y);
// Read A:
float a = (float)AModule.GetValue(x, y);
// Read B:
float b = (float)BModule.GetValue(x, y);
// Convert to RGB:
LabRgb.ToRgb(ref l, ref a, ref b);
// Now RGB.
return(new Color(l, a, b, 1f));
}
public override double GetValue(double x, double y, double z)
{
double tX = X.GetValue(x, y, z);
double tY = Y.GetValue(x, y, z);
double tZ = Z.GetValue(x, y, z);
return(SourceModule.GetValue(x + tX, y + tY, z + tZ));
}
public override double GetValue(double x, double y, double z)
{
double scaleX = X.GetValue(x, y, z);
double scaleY = Y.GetValue(x, y, z);
double scaleZ = Z.GetValue(x, y, z);
return(SourceModule.GetValue(x * scaleX, y * scaleY, z * scaleZ));
}
public override UnityEngine.Color GetColour(double x, double y)
{
// Read H:
float h = (float)HueModule.GetValue(x, y);
// Read S:
float s = (float)SaturationModule.GetValue(x, y);
// Read V:
float v = (float)BrightModule.GetValue(x, y);
// Convert to RGB:
HsvRgb.ToRgb(ref h, ref s, ref v);
// Now RGB.
return(new Color(h, s, v, 1f));
}
public override UnityEngine.Color GetColour(double x, double y)
{
// Read colour:
UnityEngine.Color col1 = SourceModule.GetColour(x, y);
// Threshold:
double threshold = ThresholdModule.GetValue(x, y);
// Smoothing range (+- half this):
double smooth = SmoothingRange.GetValue(x, y);
double hSmooth = smooth * 0.5;
// Get input colours intensity:
double intensity = (col1.r + col1.g + col1.b) / 3.0;
// High:
UnityEngine.Color high;
// Low:
UnityEngine.Color low;
// How does it compare to the minimum?
double min = threshold - hSmooth;
// Note: Equals here avoids a division by 0 when computing blending factor.
if (intensity <= min)
{
low = LowModule.GetColour(x, y);
low.a = col1.a;
return(low);
}
// And the max?
if (intensity >= threshold + hSmooth)
{
high = HighModule.GetColour(x, y);
high.a = col1.a;
return(high);
}
// Smooth. Blend between high and low.
high = HighModule.GetColour(x, y);
low = LowModule.GetColour(x, y);
// Blending factor is.. (NB: won't div by 0)
float blend = (float)((intensity - min) / smooth);
col1.r = low.r + (high.r - low.r) * blend;
col1.g = low.g + (high.g - low.g) * blend;
col1.b = low.b + (high.b - low.b) * blend;
return(col1);
}
public override UnityEngine.Color GetColour(double x, double y)
{
// Read colour:
UnityEngine.Color col1 = SourceModule.GetColour(x, y);
float lower = (float)LowerBound.GetValue(x, y);
float upper = (float)UpperBound.GetValue(x, y);
// Clamp! Ignore alpha though - it comes from col1:
if (col1.r < lower)
{
col1.r = lower;
}
else if (col1.r > upper)
{
col1.r = upper;
}
if (col1.g < lower)
{
col1.g = lower;
}
else if (col1.g > upper)
{
col1.g = upper;
}
if (col1.b < lower)
{
col1.b = lower;
}
else if (col1.b > upper)
{
col1.b = upper;
}
return(col1);
}
public override UnityEngine.Color GetColour(double x, double y)
{
// Get the angle to rotate by (rad):
double deltaAngle = RotationModule.GetValue(x, y);
// rotate the point x/y deltaAngle about 0.5/0.5
x -= 0.5;
y -= 0.5;
// Get sin/cos:
double cAngle = System.Math.Cos(deltaAngle);
double sAngle = System.Math.Sin(deltaAngle);
double tx = x * cAngle - y * sAngle;
y = y * cAngle + x * sAngle;
x = tx;
x += 0.5;
y += 0.5;
return(SourceModule.GetColour(x, y));
}
public override UnityEngine.Color GetColour(double x, double y)
{
float weight = (float)IntensityModule.GetValue(x, y);
UnityEngine.Color col1 = SourceModule.GetColour(x, y);
// Compute full sepia version:
float sepiaR = (col1.r * .393f) + (col1.g * .769f) + (col1.b * .189f);
float sepiaG = (col1.r * .349f) + (col1.g * .686f) + (col1.b * .168f);
float sepiaB = (col1.r * .272f) + (col1.g * .534f) + (col1.b * .131f);
// Blended:
return(new Color(
col1.r + (sepiaR - col1.r) * weight,
col1.g + (sepiaG - col1.g) * weight,
col1.b + (sepiaB - col1.b) * weight,
col1.a
));
}
public override UnityEngine.Color GetColour(double x, double y)
{
float threshold = (float)Threshold.GetValue(x, y);
float nThreshold = -threshold;
float a = 4f * (float)Gain.GetValue(x, y);
a += 1f;
// Read the two colours:
UnityEngine.Color pix2 = SourceModule1.GetColour(x, y);
UnityEngine.Color pix1 = SourceModule2.GetColour(x, y);
// Get deltas:
float rDelta = pix1.r - pix2.r;
float gDelta = pix1.g - pix2.g;
float bDelta = pix1.b - pix2.b;
// Threshold test:
if (rDelta <= nThreshold || rDelta >= threshold)
{
pix1.r = (a * rDelta + pix2.r);
}
if (gDelta <= nThreshold || gDelta >= threshold)
{
pix1.g = (a * gDelta + pix2.g);
}
if (bDelta <= nThreshold || bDelta >= threshold)
{
pix1.b = (a * bDelta + pix2.b);
}
return(pix1);
}
public override double GetValue(double x, double y)
{
// Radius:
double radius = RadiusModule.GetValue(x, y);
// Get width (and height):
double size = WidthModule.GetValue(x, y);
// Blur factor:
double blur = BlurModule.GetValue(x, y);
// Get delta from origin:
double dx = x - 0.5;
double dy = y - 0.5;
double angle = 0.0;
if (EdgeFunction != null)
{
// Compute the angle in 0-1 range:
angle = System.Math.Atan2(dy, dx) / (System.Math.PI * 2.0);
angle += 0.5;
}
// Offset dx and dy:
if (size > 0)
{
if (dx < 0)
{
dx = -dx;
}
dx -= size;
if (dx < 0)
{
dx = 0;
}
if (dy < 0)
{
dy = -dy;
}
dy -= size;
if (dy < 0)
{
dy = 0;
}
}
// Compute distance:
double distance = System.Math.Sqrt(dx * dx + dy * dy);
if (EdgeFunction != null)
{
// Chord adjustment:
// - Imagine a right angle triangle segment fitted perfectly into the circle.
// The right angle is sitting at the center of the circle, and one of its edges
// forms a chord of the circle.
// The chord adjustment is where we compute the distance to the chord
// and update the radius value. This results in n-polygon edges in the output.
// Read the graph at the angle in the 0-1 range and apply to radius:
radius *= 1.0 - EdgeFunction.GetValue(angle);
}
if (distance > radius)
{
// Beyond the outside of the shape.
return(0.0);
}
// Inside the shape. Inside the blur?
distance -= (radius - blur);
if (distance < 0.0)
{
return(1.0);
}
// Interpolate:
return(1.0 - distance / blur);
}
public override UnityEngine.Color GetColour(double x, double y)
{
// Get control (0-1):
double control = ControlModule.GetValue(x, y);
int count = Sources.Length - 1;
if (count == 0)
{
return(new UnityEngine.Color(0, 0, 0, 1));
}
else if (count == 1)
{
return(Sources[1].GetColour(x, y));
}
// Reduce count (such that it ranges from 0->count-1):
count--;
// Map to being relative to the points:
control *= (double)count;
int index = (int)control;
if (index < 0)
{
// Sample it:
return(Sources[1].GetColour(x, y));
}
else if (index >= count)
{
// Sample there:
return(Sources[count + 1].GetColour(x, y));
}
else
{
// Make relative:
control -= (double)index;
}
// Get current:
TextureNode current = Sources[index + 1];
if (control == 0)
{
// Just read it:
return(current.GetColour(x, y));
}
// Control is now 0-1 relative to Sources[index+1]. Get as float:
float blend = (float)control;
// Note that index is never equal to (actual count-1), therefore next is just:
TextureNode next = Sources[index + 2];
// Blend:
UnityEngine.Color col1 = current.GetColour(x, y);
UnityEngine.Color col2 = next.GetColour(x, y);
col1.r += (col1.r - col2.r) * blend;
col1.g += (col1.g - col2.g) * blend;
col1.b += (col1.b - col2.b) * blend;
col1.a += (col1.a - col2.a) * blend;
return(col1);
}