658 lines
16 KiB
C#
658 lines
16 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using UnityEngine;
|
|
|
|
[Serializable]
|
|
public class preimage_edit_class
|
|
{
|
|
public List<image_edit_class> edit_color;
|
|
|
|
public int y1;
|
|
|
|
public int x1;
|
|
|
|
public int x;
|
|
|
|
public int y;
|
|
|
|
public float frames;
|
|
|
|
public float auto_speed_time;
|
|
|
|
private float target_frame;
|
|
|
|
public float time_start;
|
|
|
|
public float time;
|
|
|
|
public bool generate;
|
|
|
|
public bool loop;
|
|
|
|
public bool generate_call;
|
|
|
|
public bool active;
|
|
|
|
public bool loop_active;
|
|
|
|
public bool import_settings;
|
|
|
|
public bool regen;
|
|
|
|
public bool regenRaw;
|
|
|
|
public bool border;
|
|
|
|
public float progress;
|
|
|
|
public Vector2 resolution;
|
|
|
|
public Vector2 resolutionRaw;
|
|
|
|
public byte[] byte1;
|
|
|
|
public bool raw;
|
|
|
|
public int xx;
|
|
|
|
public Vector2 position;
|
|
|
|
public Vector2 position2;
|
|
|
|
public Vector2 direction;
|
|
|
|
public int dir;
|
|
|
|
public Vector2 pos_old;
|
|
|
|
public bool first;
|
|
|
|
public int count;
|
|
|
|
public buffer_class inputBuffer;
|
|
|
|
public buffer_class outputBuffer;
|
|
|
|
public int radius;
|
|
|
|
public int radiusSelect;
|
|
|
|
public int mode;
|
|
|
|
public tile_class tile;
|
|
|
|
public int repeat;
|
|
|
|
public int repeatAmount;
|
|
|
|
public bool content;
|
|
|
|
public preimage_edit_class()
|
|
{
|
|
edit_color = new List<image_edit_class>();
|
|
target_frame = 30f;
|
|
active = true;
|
|
loop_active = true;
|
|
byte1 = new byte[3];
|
|
xx = 3;
|
|
position = new Vector2(x - 1, y - 1);
|
|
direction = new Vector2(1f, 0f);
|
|
dir = 1;
|
|
inputBuffer = new buffer_class();
|
|
outputBuffer = new buffer_class();
|
|
radius = 300;
|
|
radiusSelect = 300;
|
|
mode = 1;
|
|
tile = new tile_class();
|
|
repeatAmount = 3;
|
|
content = true;
|
|
}
|
|
|
|
public virtual float calc_color_pos(Color color, Color color_start, Color color_end)
|
|
{
|
|
Color color2 = color_start;
|
|
Color color3 = default(Color);
|
|
if (!(color_start.r <= color_end.r))
|
|
{
|
|
color_start.r = color_end.r;
|
|
color_end.r = color2.r;
|
|
}
|
|
if (!(color_start.g <= color_end.g))
|
|
{
|
|
color_start.g = color_end.g;
|
|
color_end.g = color2.g;
|
|
}
|
|
if (!(color_start.b <= color_end.b))
|
|
{
|
|
color_start.b = color_end.b;
|
|
color_end.b = color2.b;
|
|
}
|
|
color3 = color_end - color_start;
|
|
color -= color_start;
|
|
float result;
|
|
if (color.r < 0f || color.g < 0f || !(color.b >= 0f))
|
|
{
|
|
result = -1f;
|
|
}
|
|
else if (color.r > color3.r || color.g > color3.g || !(color.b <= color3.b))
|
|
{
|
|
result = -1f;
|
|
}
|
|
else
|
|
{
|
|
float num = color3.r + color3.g + color3.b;
|
|
float num2 = color.r + color.g + color.b;
|
|
result = ((num == 0f) ? 1f : (num2 / num));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public virtual Color calc_color_from_pos(float pos, Color color_start, Color color_end)
|
|
{
|
|
Color color = color_start;
|
|
Color color2 = default(Color);
|
|
if (!(color_start.r <= color_end.r))
|
|
{
|
|
color_start.r = color_end.r;
|
|
color_end.r = color.r;
|
|
}
|
|
if (!(color_start.g <= color_end.g))
|
|
{
|
|
color_start.g = color_end.g;
|
|
color_end.g = color.g;
|
|
}
|
|
if (!(color_start.b <= color_end.b))
|
|
{
|
|
color_start.b = color_end.b;
|
|
color_end.b = color.b;
|
|
}
|
|
color2 = color_end - color_start;
|
|
return color_start + new Color(color2.r * pos, color2.g * pos, color2.b * pos);
|
|
}
|
|
|
|
public virtual void swap_color(int color_index1, int color_index2)
|
|
{
|
|
image_edit_class value = edit_color[color_index1];
|
|
edit_color[color_index1] = edit_color[color_index2];
|
|
edit_color[color_index2] = value;
|
|
}
|
|
|
|
public virtual void copy_color(int color_index1, int color_index2)
|
|
{
|
|
edit_color[color_index1].color1_start = edit_color[color_index2].color1_start;
|
|
edit_color[color_index1].color1_end = edit_color[color_index2].color1_end;
|
|
edit_color[color_index1].curve1 = edit_color[color_index2].curve1;
|
|
edit_color[color_index1].color2_start = edit_color[color_index2].color2_start;
|
|
edit_color[color_index1].color2_end = edit_color[color_index2].color2_end;
|
|
edit_color[color_index1].curve2 = edit_color[color_index2].curve2;
|
|
edit_color[color_index1].strength = edit_color[color_index2].strength;
|
|
edit_color[color_index1].output = edit_color[color_index2].output;
|
|
edit_color[color_index1].active = edit_color[color_index2].active;
|
|
edit_color[color_index1].solid_color = edit_color[color_index2].solid_color;
|
|
}
|
|
|
|
public virtual void convert_texture_raw(bool multithread)
|
|
{
|
|
int num = 0;
|
|
Color color = default(Color);
|
|
Color color2 = default(Color);
|
|
Color color3 = default(Color);
|
|
float num2 = default(float);
|
|
float num3 = default(float);
|
|
float num4 = default(float);
|
|
float num5 = default(float);
|
|
bool flag = true;
|
|
auto_speed_time = Time.realtimeSinceStartup;
|
|
pos_old.y = -100f;
|
|
y = y1;
|
|
while ((float)y < inputBuffer.innerRect.height + inputBuffer.offset.y)
|
|
{
|
|
xx = 3;
|
|
position = new Vector2(-1f, y - 1);
|
|
direction = new Vector2(1f, 0f);
|
|
dir = 1;
|
|
count = 0;
|
|
x = (int)(inputBuffer.offset.x + (float)x1);
|
|
while ((float)x < inputBuffer.innerRect.width + inputBuffer.offset.x)
|
|
{
|
|
color = GetPixelRaw(inputBuffer, x, y);
|
|
color3 = color;
|
|
for (num = 0; num < edit_color.Count; num++)
|
|
{
|
|
if (!edit_color[num].active && !edit_color[num].solid_color)
|
|
{
|
|
continue;
|
|
}
|
|
num2 = calc_color_pos(color, edit_color[num].color1_start, edit_color[num].color1_end);
|
|
if (num2 == -1f)
|
|
{
|
|
continue;
|
|
}
|
|
num2 = edit_color[num].curve1.Evaluate(num2);
|
|
num3 = edit_color[num].curve2.Evaluate(num2);
|
|
color2 = calc_color_from_pos(num3, edit_color[num].color2_start, edit_color[num].color2_end);
|
|
num4 = edit_color[num].strength;
|
|
if (!edit_color[num].solid_color)
|
|
{
|
|
if (edit_color[num].output == image_output_enum.content)
|
|
{
|
|
if ((float)x == pos_old.x + 1f && (float)y == pos_old.y && xx > 3)
|
|
{
|
|
if (dir == 1)
|
|
{
|
|
if (count == 0)
|
|
{
|
|
position.x += 1f;
|
|
xx -= 2;
|
|
}
|
|
else
|
|
{
|
|
count--;
|
|
}
|
|
}
|
|
else if (dir == 2)
|
|
{
|
|
xx -= 2;
|
|
}
|
|
else if (dir == 3 || dir == 4)
|
|
{
|
|
position.x = x + (xx - 1) / 2;
|
|
position.y = y - (xx - 1) / 2;
|
|
dir = 2;
|
|
count = 0;
|
|
direction = new Vector2(-1f, 0f);
|
|
}
|
|
color2 = content_fill_raw(x, y, edit_color[num].color1_start, edit_color[num].color1_end, edit_color[num].color2_start, false);
|
|
}
|
|
else
|
|
{
|
|
color2 = content_fill_raw(x, y, edit_color[num].color1_start, edit_color[num].color1_end, edit_color[num].color2_start, true);
|
|
}
|
|
pos_old = new Vector2(x, y);
|
|
color3 = color2;
|
|
}
|
|
switch (edit_color[num].output)
|
|
{
|
|
case image_output_enum.add:
|
|
color3.r += color2.r * num4;
|
|
color3.g += color2.g * num4;
|
|
color3.b += color2.b * num4;
|
|
break;
|
|
case image_output_enum.subtract:
|
|
color3.r -= color2.r * num4;
|
|
color3.g -= color2.g * num4;
|
|
color3.b -= color2.b * num4;
|
|
break;
|
|
case image_output_enum.change:
|
|
color3.r = color.r * (1f - num4) + color2.r * num4;
|
|
color3.g = color.g * (1f - num4) + color2.g * num4;
|
|
color3.b = color.b * (1f - num4) + color2.b * num4;
|
|
break;
|
|
case image_output_enum.multiply:
|
|
color3.r *= color2.r * num4;
|
|
color3.g *= color2.g * num4;
|
|
color3.b *= color2.b * num4;
|
|
break;
|
|
case image_output_enum.divide:
|
|
if (color2.r * num4 != 0f)
|
|
{
|
|
color3.r = color.r / (color2.r * num4);
|
|
}
|
|
if (color2.g * num4 != 0f)
|
|
{
|
|
color3.g = color.g / (color2.g * num4);
|
|
}
|
|
if (color2.b * num4 != 0f)
|
|
{
|
|
color3.b = color.b / (color2.b * num4);
|
|
}
|
|
break;
|
|
case image_output_enum.difference:
|
|
color3.r = Mathf.Abs(color2.r * num4 - color.r);
|
|
color3.g = Mathf.Abs(color2.g * num4 - color.g);
|
|
color3.b = Mathf.Abs(color2.b * num4 - color.b);
|
|
break;
|
|
case image_output_enum.average:
|
|
color3.r = (color.r + color2.r * num4) / 2f;
|
|
color3.g = (color.g + color2.g * num4) / 2f;
|
|
color3.b = (color.b + color2.b * num4) / 2f;
|
|
break;
|
|
case image_output_enum.max:
|
|
if (!(color2.r * num4 <= color.r))
|
|
{
|
|
color3.r = color2.r * num4;
|
|
}
|
|
if (!(color2.g * num4 <= color.g))
|
|
{
|
|
color3.g = color2.g * num4;
|
|
}
|
|
if (!(color2.b * num4 <= color.b))
|
|
{
|
|
color3.b = color2.b * num4;
|
|
}
|
|
break;
|
|
case image_output_enum.min:
|
|
if (!(color2.r * num4 >= color.r))
|
|
{
|
|
color3.r = color2.r * num4;
|
|
}
|
|
if (!(color2.g * num4 >= color.g))
|
|
{
|
|
color3.g = color2.g * num4;
|
|
}
|
|
if (!(color2.b * num4 >= color.b))
|
|
{
|
|
color3.b = color2.b * num4;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
color3.r += 1f - num2;
|
|
color3.g += num2;
|
|
color3.b += 1f;
|
|
}
|
|
}
|
|
if (!(color3[0] <= 1f))
|
|
{
|
|
color3[0] = 1f;
|
|
}
|
|
else if (!(color3[0] >= 0f))
|
|
{
|
|
color3[0] = 0f;
|
|
}
|
|
if (!(color3[1] <= 1f))
|
|
{
|
|
color3[1] = 1f;
|
|
}
|
|
else if (!(color3[1] >= 0f))
|
|
{
|
|
color3[1] = 0f;
|
|
}
|
|
if (!(color3[2] <= 1f))
|
|
{
|
|
color3[2] = 1f;
|
|
}
|
|
else if (!(color3[2] >= 0f))
|
|
{
|
|
color3[2] = 0f;
|
|
}
|
|
SetPixelRaw(outputBuffer, x, y, color3);
|
|
if (!(Time.realtimeSinceStartup - auto_speed_time <= 1f / target_frame) && multithread)
|
|
{
|
|
y1 = y;
|
|
x1 = (int)((float)x - inputBuffer.offset.x + 1f);
|
|
if (mode == 2)
|
|
{
|
|
time = Time.realtimeSinceStartup - time_start;
|
|
}
|
|
return;
|
|
}
|
|
x++;
|
|
}
|
|
x1 = 0;
|
|
y++;
|
|
}
|
|
generate = false;
|
|
}
|
|
|
|
public virtual Color content_fill_raw(int _x, int _y, Color exclude_start, Color exclude_end, Color exclude2, bool reset)
|
|
{
|
|
Vector2 vector = default(Vector2);
|
|
Vector2 vector2 = default(Vector2);
|
|
Color color = default(Color);
|
|
Color color2 = default(Color);
|
|
Color color3 = default(Color);
|
|
float num = 0f;
|
|
float num2 = 360f;
|
|
float num3 = 20f;
|
|
Vector2 vector3 = default(Vector2);
|
|
Vector2 vector4 = default(Vector2);
|
|
float num4 = default(float);
|
|
float num5 = default(float);
|
|
bool flag = false;
|
|
bool flag2 = false;
|
|
float num6 = default(float);
|
|
float num7 = default(float);
|
|
bool flag3 = false;
|
|
bool flag4 = false;
|
|
if (reset)
|
|
{
|
|
xx = 3;
|
|
position = new Vector2(_x - 1, _y - 1);
|
|
direction = new Vector2(1f, 0f);
|
|
dir = 1;
|
|
count = 0;
|
|
}
|
|
do
|
|
{
|
|
IL_00bb:
|
|
color = GetPixelRaw(inputBuffer, (long)position.x, (long)position.y);
|
|
if (!color_in_range(exclude_start, exclude_end, color))
|
|
{
|
|
flag = true;
|
|
break;
|
|
}
|
|
count++;
|
|
if (count >= xx && dir == 1)
|
|
{
|
|
direction = new Vector2(0f, 1f);
|
|
count = 0;
|
|
dir = 2;
|
|
}
|
|
else if (count >= xx - 1 && dir == 2)
|
|
{
|
|
direction = new Vector2(-1f, 0f);
|
|
count = 0;
|
|
dir = 3;
|
|
}
|
|
else if (count >= xx - 1 && dir == 3)
|
|
{
|
|
direction = new Vector2(0f, -1f);
|
|
count = 0;
|
|
dir = 4;
|
|
}
|
|
else if (count >= xx - 2 && dir == 4)
|
|
{
|
|
direction = new Vector2(1f, 0f);
|
|
count = 0;
|
|
position += new Vector2(-1f, -2f);
|
|
dir = 1;
|
|
xx += 2;
|
|
goto IL_00bb;
|
|
}
|
|
position += direction;
|
|
}
|
|
while (!flag);
|
|
vector3.x = position.x - (float)_x;
|
|
vector3.y = position.y - (float)_y;
|
|
num4 = vector3.magnitude;
|
|
if (repeat < 1 && !(num4 <= 4f))
|
|
{
|
|
for (int i = (int)(position.y - 1f); (float)i <= position.y + 1f; i++)
|
|
{
|
|
for (int j = (int)(position.x - 1f); (float)j <= position.x + 1f; j++)
|
|
{
|
|
color2 = GetPixelRaw(inputBuffer, j, i);
|
|
if (!(color2[0] > exclude2[0]) && !(color2[1] > exclude2[1]) && !(color2[2] > exclude2[2]))
|
|
{
|
|
SetPixelRaw(outputBuffer, j, i, new Color(0f, 0f, 0f));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (repeat < repeatAmount - 1)
|
|
{
|
|
vector4 = vector3 / num4 * radius;
|
|
position2.x = (float)_x + vector4.x;
|
|
position2.y = (float)_y + vector4.y;
|
|
color = GetPixelRaw(inputBuffer, (long)position2.x, (long)position2.y);
|
|
if (color_in_range(exclude_start, exclude_end, color))
|
|
{
|
|
regen = true;
|
|
flag4 = true;
|
|
}
|
|
}
|
|
if (!flag4)
|
|
{
|
|
color2 = GetPixelRaw(outputBuffer, _x - 1, _y);
|
|
if (!color_in_range(exclude_start, exclude_end, color2))
|
|
{
|
|
num5 = color_difference(color2, color);
|
|
if (GetPixelRaw(inputBuffer, _x - 1, _y) == color2)
|
|
{
|
|
num5 *= 10f;
|
|
}
|
|
if (!(num5 <= num3))
|
|
{
|
|
color3 += color2 * (num5 / num2);
|
|
num += num5 / num2;
|
|
}
|
|
}
|
|
color2 = GetPixelRaw(outputBuffer, _x, _y - 1);
|
|
if (!color_in_range(exclude_start, exclude_end, color2))
|
|
{
|
|
num5 = color_difference(color2, color);
|
|
if (GetPixelRaw(inputBuffer, _x, _y - 1) == color2)
|
|
{
|
|
num5 *= 10f;
|
|
}
|
|
if (!(num5 <= num3))
|
|
{
|
|
color3 += color2 * (num5 / num2);
|
|
num += num5 / num2;
|
|
}
|
|
}
|
|
color2 = GetPixelRaw(outputBuffer, _x + 1, _y);
|
|
if (!color_in_range(exclude_start, exclude_end, color2))
|
|
{
|
|
num5 = color_difference(color2, color);
|
|
if (GetPixelRaw(inputBuffer, _x + 1, _y) == color2)
|
|
{
|
|
num5 *= 10f;
|
|
}
|
|
if (!(num5 <= num3))
|
|
{
|
|
color3 += color2 * (num5 / num2);
|
|
num += num5 / num2;
|
|
}
|
|
}
|
|
color2 = GetPixelRaw(outputBuffer, _x, _y + 1);
|
|
if (!color_in_range(exclude_start, exclude_end, color2))
|
|
{
|
|
num5 = color_difference(color2, color);
|
|
if (GetPixelRaw(inputBuffer, _x, _y + 1) == color2)
|
|
{
|
|
num5 *= 10f;
|
|
}
|
|
if (!(num5 <= num3))
|
|
{
|
|
color3 += color2 * (num5 / num2);
|
|
num += num5 / num2;
|
|
}
|
|
}
|
|
color += color3;
|
|
color /= 1f + num;
|
|
}
|
|
SetPixelRaw(outputBuffer, _x, _y, color);
|
|
return color;
|
|
}
|
|
|
|
public virtual Color GetPixelRaw(buffer_class buffer, long x, long y)
|
|
{
|
|
Color result;
|
|
if (mode == 1)
|
|
{
|
|
if (x < 0)
|
|
{
|
|
x = -x;
|
|
}
|
|
else if (!((float)x <= buffer.outerRect.width - 1f))
|
|
{
|
|
x = (long)((float)x - ((float)x - (buffer.outerRect.width - 1f)));
|
|
}
|
|
if (y < 0)
|
|
{
|
|
y = -y;
|
|
}
|
|
else if (!((float)y <= buffer.outerRect.height - 1f))
|
|
{
|
|
y = (long)((float)y - ((float)y - (buffer.outerRect.height - 1f)));
|
|
}
|
|
}
|
|
else if (x < 0 || (float)x > buffer.outerRect.width - 1f || y < 0 || !((float)y <= buffer.outerRect.height - 1f))
|
|
{
|
|
result = GetPixelRaw2(buffer, x, y);
|
|
goto IL_0154;
|
|
}
|
|
ulong num = (ulong)(buffer.outerRect.width * 3f * (float)y + (float)(x * 3));
|
|
result = new Color((float)(int)buffer.bytes[(uint)num] * 1f / 255f, (float)(int)buffer.bytes[(uint)(num + 1u)] * 1f / 255f, (float)(int)buffer.bytes[(uint)(num + 2u)] * 1f / 255f);
|
|
goto IL_0154;
|
|
IL_0154:
|
|
return result;
|
|
}
|
|
|
|
public virtual void SetPixelRaw(buffer_class buffer, long x, long y, Color color)
|
|
{
|
|
if (x < 0)
|
|
{
|
|
x = -x;
|
|
}
|
|
else if (!((float)x <= buffer.outerRect.width - 1f))
|
|
{
|
|
x = (long)((float)x - ((float)x - (buffer.outerRect.width - 1f)));
|
|
}
|
|
if (y < 0)
|
|
{
|
|
y = -y;
|
|
}
|
|
else if (!((float)y <= buffer.outerRect.height - 1f))
|
|
{
|
|
y = (long)((float)y - ((float)y - (buffer.outerRect.height - 1f)));
|
|
}
|
|
ulong num = (ulong)(buffer.outerRect.width * 3f * (float)y + (float)(x * 3));
|
|
buffer.bytes[(uint)num] = (byte)(color[0] * 255f);
|
|
buffer.bytes[(uint)(num + 1u)] = (byte)(color[1] * 255f);
|
|
buffer.bytes[(uint)(num + 2u)] = (byte)(color[2] * 255f);
|
|
}
|
|
|
|
public virtual Color GetPixelRaw2(buffer_class buffer, long x, long y)
|
|
{
|
|
x = (long)((float)x + buffer.outerRect.x);
|
|
y = (long)((float)y + buffer.outerRect.y);
|
|
if (x < 0)
|
|
{
|
|
x = -x;
|
|
}
|
|
else if (!((float)x <= buffer.resolution.x - 1f))
|
|
{
|
|
x = (long)((float)x - ((float)x - buffer.resolution.x - 1f));
|
|
}
|
|
if (y < 0)
|
|
{
|
|
y = -y;
|
|
}
|
|
else if (!((float)y <= buffer.resolution.y - 1f))
|
|
{
|
|
y = (long)((float)y - ((float)y - buffer.resolution.y - 1f));
|
|
}
|
|
ulong num = (ulong)((long)buffer.row * y + x * 3);
|
|
buffer.file.Seek((long)num, SeekOrigin.Begin);
|
|
byte[] array = new byte[3];
|
|
buffer.file.Read(array, 0, 3);
|
|
return new Color((float)(int)array[0] * 1f / 255f, (float)(int)array[1] * 1f / 255f, (float)(int)array[2] * 1f / 255f);
|
|
}
|
|
|
|
public virtual bool color_in_range(Color color_start, Color color_end, Color color)
|
|
{
|
|
return (!(color[0] < color_start[0]) && !(color[0] > color_end[0]) && !(color[1] < color_start[1]) && !(color[1] > color_end[1]) && !(color[2] < color_start[2]) && !(color[2] > color_end[2])) ? true : false;
|
|
}
|
|
|
|
public virtual int color_difference(Color color1, Color color2)
|
|
{
|
|
return (int)((Mathf.Abs(color1[0] - color2[0]) + Mathf.Abs(color1[1] - color2[1]) + Mathf.Abs(color1[2] - color2[1])) * 255f);
|
|
}
|
|
}
|