etc/HeavenStudioPlus
0
0
Fork 0
mirror of https://github.com/RHeavenStudioPlus/HeavenStudioPlus.git synced 2024-11-14 13:45:10 +00:00
Code Issues Projects Releases Packages Wiki Activity

Change Project License to MIT (#700)

Browse source 
* license change

replace unneeded package

* reword this
This commit is contained in:
minenice55 2024-02-16 01:17:16 -05:00 committed by GitHub
parent 172e3850a5
commit dd9a06ad52
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
153 changed files with 167 additions and 5439 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

41
Assets/Plugins/Color picker/ColorPreview.cs
View file

@ -2,7 +2,6 @@ using UnityEngine;
using UnityEngine.UI;
using TMPro;
using Starpelly;
public class ColorPreview : MonoBehaviour
{
@ -21,18 +20,18 @@ public class ColorPreview : MonoBehaviour
public void ChangeColor(Color c)
{
colorPicker.color = c;
hex.text = c.Color2Hex();
hex.text = Color2Hex(c);
}
public void OnColorChanged(Color c)
{
previewGraphic.color = c;
hex.text = c.Color2Hex();
hex.text = Color2Hex(c);
}
public void SetColorFromHex(string hex)
{
colorPicker.color = Starpelly.Colors.Hex2RGB(hex);
colorPicker.color = Hex2RGB(hex);
}
private void OnDestroy()
@ -45,4 +44,38 @@ public class ColorPreview : MonoBehaviour
{
SetColorFromHex(hex.text);
}
static string Color2Hex(Color color)
{
Color32 col = (Color32)color;
string hex = col.r.ToString("X2") + col.g.ToString("X2") + col.b.ToString("X2");
return hex;
}
/// <summary>
/// Converts a Hexadecimal Color to an RGB Color.
/// </summary>
static Color Hex2RGB(string hex)
{
if (hex is null or "") return Color.black;
try
{
hex = hex.Replace("0x", "");//in case the string is formatted 0xFFFFFF
hex = hex.Replace("#", "");//in case the string is formatted #FFFFFF
byte a = 255;//assume fully visible unless specified in hex
byte r = byte.Parse(hex.Substring(0, 2), System.Globalization.NumberStyles.HexNumber);
byte g = byte.Parse(hex.Substring(2, 2), System.Globalization.NumberStyles.HexNumber);
byte b = byte.Parse(hex.Substring(4, 2), System.Globalization.NumberStyles.HexNumber);
//Only use alpha if the string has enough characters
if (hex.Length >= 8)
{
a = byte.Parse(hex.Substring(6, 2), System.Globalization.NumberStyles.HexNumber);
}
return new Color32(r, g, b, a);
}
catch
{
return Color.black;
}
}
}

8
Assets/Plugins/Starpelly.meta
View file

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: cb987a8733a64924aa4c1bcbe27e6430
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

115
Assets/Plugins/Starpelly/Anchors.cs
View file

@ -1,115 +0,0 @@
using UnityEngine;
namespace Starpelly
{
public class Anchors
{
//------------Top-------------------
public static void TopLeft(GameObject uiObject)
{
RectTransform uitransform = uiObject.GetComponent<RectTransform>();
uitransform.anchorMin = new Vector2(0, 1);
uitransform.anchorMax = new Vector2(0, 1);
uitransform.pivot = new Vector2(0, 1);
}
public static void TopMiddle(GameObject uiObject)
{
RectTransform uitransform = uiObject.GetComponent<RectTransform>();
uitransform.anchorMin = new Vector2(0.5f, 1);
uitransform.anchorMax = new Vector2(0.5f, 1);
uitransform.pivot = new Vector2(0.5f, 1);
}
public static void TopRight(GameObject uiObject)
{
RectTransform uitransform = uiObject.GetComponent<RectTransform>();
uitransform.anchorMin = new Vector2(1, 1);
uitransform.anchorMax = new Vector2(1, 1);
uitransform.pivot = new Vector2(1, 1);
}
//------------Middle-------------------
public static void MiddleLeft(GameObject uiObject)
{
RectTransform uitransform = uiObject.GetComponent<RectTransform>();
uitransform.anchorMin = new Vector2(0, 0.5f);
uitransform.anchorMax = new Vector2(0, 0.5f);
uitransform.pivot = new Vector2(0, 0.5f);
}
public static void Mmiddle(GameObject uiObject)
{
RectTransform uitransform = uiObject.GetComponent<RectTransform>();
uitransform.anchorMin = new Vector2(0.5f, 0.5f);
uitransform.anchorMax = new Vector2(0.5f, 0.5f);
uitransform.pivot = new Vector2(0.5f, 0.5f);
}
public static void MiddleRight(GameObject uiObject)
{
RectTransform uitransform = uiObject.GetComponent<RectTransform>();
uitransform.anchorMin = new Vector2(1, 0.5f);
uitransform.anchorMax = new Vector2(1, 0.5f);
uitransform.pivot = new Vector2(1, 0.5f);
}
//------------Bottom-------------------
public static void BottomLeft(GameObject uiObject)
{
RectTransform uitransform = uiObject.GetComponent<RectTransform>();
uitransform.anchorMin = new Vector2(0, 0);
uitransform.anchorMax = new Vector2(0, 0);
uitransform.pivot = new Vector2(0, 0);
}
public static void BottomMiddle(GameObject uiObject)
{
RectTransform uitransform = uiObject.GetComponent<RectTransform>();
uitransform.anchorMin = new Vector2(0.5f, 0);
uitransform.anchorMax = new Vector2(0.5f, 0);
uitransform.pivot = new Vector2(0.5f, 0);
}
public static void BottomRight(GameObject uiObject)
{
RectTransform uitransform = uiObject.GetComponent<RectTransform>();
uitransform.anchorMin = new Vector2(1, 0);
uitransform.anchorMax = new Vector2(1, 0);
uitransform.pivot = new Vector2(1, 0);
}
}
public static class RectTransformExtensions
{
public static void SetLeft(this RectTransform rt, float left)
{
rt.offsetMin = new Vector2(left, rt.offsetMin.y);
}
public static void SetRight(this RectTransform rt, float right)
{
rt.offsetMax = new Vector2(-right, rt.offsetMax.y);
}
public static void SetTop(this RectTransform rt, float top)
{
rt.offsetMax = new Vector2(rt.offsetMax.x, -top);
}
public static void SetBottom(this RectTransform rt, float bottom)
{
rt.offsetMin = new Vector2(rt.offsetMin.x, bottom);
}
}
}

11
Assets/Plugins/Starpelly/Anchors.cs.meta
View file

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 1d8c3539b2e2fb543b570b5d5e8cc79a
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

41
Assets/Plugins/Starpelly/Colors.cs
View file

@ -1,41 +0,0 @@
using UnityEngine;
namespace Starpelly
{
public static class Colors
{
public static string Color2Hex(this Color color)
{
Color32 col = (Color32)color;
string hex = col.r.ToString("X2") + col.g.ToString("X2") + col.b.ToString("X2");
return hex;
}
/// <summary>
/// Converts a Hexadecimal Color to an RGB Color.
/// </summary>
public static Color Hex2RGB(this string hex)
{
if (hex is null or "") return Color.black;
try
{
hex = hex.Replace("0x", "");//in case the string is formatted 0xFFFFFF
hex = hex.Replace("#", "");//in case the string is formatted #FFFFFF
byte a = 255;//assume fully visible unless specified in hex
byte r = byte.Parse(hex.Substring(0, 2), System.Globalization.NumberStyles.HexNumber);
byte g = byte.Parse(hex.Substring(2, 2), System.Globalization.NumberStyles.HexNumber);
byte b = byte.Parse(hex.Substring(4, 2), System.Globalization.NumberStyles.HexNumber);
//Only use alpha if the string has enough characters
if (hex.Length >= 8)
{
a = byte.Parse(hex.Substring(6, 2), System.Globalization.NumberStyles.HexNumber);
}
return new Color32(r, g, b, a);
}
catch
{
return Color.black;
}
}
}
}

11
Assets/Plugins/Starpelly/Colors.cs.meta
View file

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 50a7b803bf8f71447b31651201c679bd
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

13
Assets/Plugins/Starpelly/Common.cs
View file

@ -1,13 +0,0 @@
using System;
using System.Runtime.InteropServices;
using Starpelly.Enums.Windows;
namespace Starpelly.Common
{
[StructLayout(LayoutKind.Sequential)]
public struct POINT
{
public int x;
public int y;
}
}

11
Assets/Plugins/Starpelly/Common.cs.meta
View file

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 443faccde9dc53c488a2e5a987167620
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Plugins/Starpelly/Enums.meta
View file

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: af122b943aa4c9b42aff726e52d9ab65
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

34
Assets/Plugins/Starpelly/Enums/StringType.cs
View file

@ -1,34 +0,0 @@
namespace Starpelly.Enums.Strings
{
public enum StringType : int
{
/// <summary>
/// Both uppercase and lowercase letters in english.
/// </summary>
Alpha,
/// <summary>
/// All numbers ranging from 0-9
/// </summary>
Numeric,
/// <summary>
/// Both uppercase and lowercase letters with all numbers ranging from 0-9. (english)
/// </summary>
Alphanumeric,
/// <summary>
/// All uppercase letters in english.
/// </summary>
Uppercase,
/// <summary>
/// All lowercase letters in english.
/// </summary>
Lowercase,
/// <summary>
/// All punctuation marks on the QWERTY keyboard. (Also contains special keys)
/// </summary>
Punctuation,
/// <summary>
/// All of the above.
/// </summary>
ALL
}
}

108
Assets/Plugins/Starpelly/Enums/Windows.cs
View file

@ -1,108 +0,0 @@
using Starpelly.Common;
using System;
using System.Runtime.InteropServices;
namespace Starpelly.Enums.Windows
{
public enum WindowsCursor : int
{
StandardArrowAndSmallHourglass = 32650,
StandardArrow = 32512,
Crosshair = 32515,
Hand = 32649,
ArrowAndQuestionMark = 32651,
IBeam = 32513,
/// <summary>
/// Obsolete for applications marked version 4.0 or later.
/// </summary>
[System.Obsolete]
Icon = 32641,
SlashedCircle = 32648,
/// <summary>
/// Obsolete for applications marked version 4.0 or later. Use FourPointedArrowPointingNorthSouthEastAndWest
/// </summary>
[System.Obsolete]
Size = 32640,
FourPointedArrowPointingNorthSouthEastAndWest = 32646,
DoublePointedArrowPointingNortheastAndSouthwest = 32643,
DoublePointedArrowPointingNorthAndSouth = 32645,
DoublePointedArrowPointingNorthwestAndSoutheast = 32642,
DoublePointedArrowPointingWestAndEast = 32644,
VerticalArrow = 32516,
Hourglass = 32514
}
[Flags]
public enum SendInputEventType : uint
{
InputMouse,
InputKeyboard,
InputHardware
}
[StructLayout(LayoutKind.Sequential)]
public struct MOUSEINPUT
{
public int dx;
public int dy;
public uint mouseData;
public MouseEventFlags dwFlags;
public uint time;
public IntPtr dwExtraInfo;
}
[StructLayout(LayoutKind.Sequential)]
public struct KEYBOARDINPUT
{
public ushort wVk;
public ushort wScan;
public uint dwFlags;
public uint time;
public IntPtr dwExtraInfo;
}
[StructLayout(LayoutKind.Sequential)]
public struct HARDWAREINPUT
{
public int uMsg;
public short wParamL;
public short wParamH;
}
[StructLayout(LayoutKind.Explicit)]
public struct MOUSEANDKEYBOARDINPUT
{
[FieldOffset(0)]
public MOUSEINPUT mi;
[FieldOffset(0)]
public KEYBOARDINPUT ki;
[FieldOffset(0)]
public HARDWAREINPUT hi;
}
[Flags]
public enum MouseEventFlags : uint
{
MOUSEEVENT_MOVE = 0x0001,
MOUSEEVENT_LEFTDOWN = 0x0002,
MOUSEEVENT_LEFTUP = 0x0004,
MOUSEEVENT_RIGHTDOWN = 0x0008,
MOUSEEVENT_RIGHTUP = 0x0010,
MOUSEEVENT_MIDDLEDOWN = 0x0020,
MOUSEEVENT_MIDDLEUP = 0x0040,
MOUSEEVENT_XDOWN = 0x0080,
MOUSEEVENT_XUP = 0x0100,
MOUSEEVENT_WHEEL = 0x0800,
MOUSEEVENT_VIRTUALDESK = 0x4000,
MOUSEEVENT_ABSOLUTE = 0x8000
}
[StructLayout(LayoutKind.Sequential)]
public struct INPUT
{
public SendInputEventType type;
public MOUSEANDKEYBOARDINPUT mkhi;
}
}

11
Assets/Plugins/Starpelly/Enums/Windows.cs.meta
View file

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 9aa3c38600fe0124ea40791c379eb5d0
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

18
Assets/Plugins/Starpelly/Extensions.cs
View file

@ -1,18 +0,0 @@
using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
public static class Extensions
{
public static T DeepClone<T>(this T obj)
{
using (MemoryStream stream = new MemoryStream())
{
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(stream, obj);
stream.Position = 0;
return (T)formatter.Deserialize(stream);
}
}
}

11
Assets/Plugins/Starpelly/Extensions.cs.meta
View file

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 98be75cbdf7662d43bf84e7f1ac7d58e
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

93
Assets/Plugins/Starpelly/Math.cs
View file

@ -1,93 +0,0 @@
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
namespace Starpelly
{
public static class Mathp
{
/// <summary>
/// Rounds float to nearest interval.
/// </summary>
public static float Round2Nearest(float a, float interval)
{
return a = a - (a % interval);
}
/// <summary>
/// Gets the difference between two floats.
/// </summary>
public static float Difference(float num1, float num2)
{
float cout;
cout = Mathf.Max(num2, num1) - Mathf.Min(num1, num2);
return cout;
}
/// <summary>
/// Returns the closest value in a list compared to value given.
/// </summary>
public static float GetClosestInList(List<float> list, float compareTo)
{
if (list.Count > 0)
return list.Aggregate((x, y) => Mathf.Abs(x - compareTo) < Mathf.Abs(y - compareTo) ? x : y);
else
return -40;
}
/// <summary>
/// Get the numbers after a decimal.
/// </summary>
public static float GetDecimalFromFloat(float number)
{
return number % 1; // this is simple as fuck, but i'm dumb and forget this all the time
}
/// <summary>
/// Converts two numbers to a range of 0 - 1
/// </summary>
/// <param name="val">The input value.</param>
/// <param name="min">The min input.</param>
/// <param name="max">The max input.</param>
public static float Normalize(float val, float min, float max)
{
return (val - min) / (max - min);
}
/// <summary>
/// Converts a normalized value to a normal float.
/// </summary>
/// <param name="val">The normalized value.</param>
/// <param name="min">The min input.</param>
/// <param name="max">The max input.</param>
public static float DeNormalize(float val, float min, float max)
{
return (val * (max - min) + min);
}
/// <summary>
/// Returns true if a value is within a certain range.
/// </summary>
public static bool IsWithin(this float val, float min, float max)
{
return val >= min && val <= max;
}
/// <summary>
/// Returns true if a value is within a certain range.
/// </summary>
public static bool IsWithin(this Vector2 val, Vector2 min, Vector2 max)
{
return val.x.IsWithin(min.x, max.x) && val.y.IsWithin(min.y, max.y);
}
/// <summary>
/// Returns true if value is between two numbers.
/// </summary>
public static bool IsBetween<T>(this T item, T start, T end)
{
return Comparer<T>.Default.Compare(item, start) >= 0
&& Comparer<T>.Default.Compare(item, end) <= 0;
}
}
}

11
Assets/Plugins/Starpelly/Math.cs.meta
View file

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 09ae937b4a8b92d4386ba5172d1ad67f
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

23
Assets/Plugins/Starpelly/OS.cs
View file

@ -1,23 +0,0 @@
namespace Starpelly
{
public static class OS
{
private static readonly OperatingSystem.IOperatingSystem _os;
static OS()
{
#if UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN
_os = new OperatingSystem.Windows();
#elif UNITY_STANDALONE_LINUX || UNITY_EDITOR_LINUX
_os = new OperatingSystem.Linux();
#elif UNITY_STANDALONE_OSX || UNITY_EDITOR_OSX
_os = new OperatingSystem.MacOS();
#endif
}
public static void ChangeWindowTitle(string newTitle)
{
_os.ChangeWindowTitle(newTitle);
}
}
}

3
Assets/Plugins/Starpelly/OS.cs.meta
View file

@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: 36edcede4a1a4ef9bb0902354c3be0d1
timeCreated: 1655775758

3
Assets/Plugins/Starpelly/OperatingSystem.meta
View file

@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: 7b17a1aeeb0f43bb805dc7ac03408ebb
timeCreated: 1655775758

7
Assets/Plugins/Starpelly/OperatingSystem/IOperatingSystem.cs
View file

@ -1,7 +0,0 @@
namespace Starpelly.OperatingSystem
{
public interface IOperatingSystem
{
public void ChangeWindowTitle(string newTitle);
}
}

3
Assets/Plugins/Starpelly/OperatingSystem/IOperatingSystem.cs.meta
View file

@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: 8bb82376a44e4330b6398deddb17d282
timeCreated: 1655775758

16
Assets/Plugins/Starpelly/OperatingSystem/Linux.cs
View file

@ -1,16 +0,0 @@
#if UNITY_EDITOR_LINUX || UNITY_STANDALONE_LINUX
using System.Diagnostics;
namespace Starpelly.OperatingSystem
{
public class Linux : IOperatingSystem
{
public void ChangeWindowTitle(string newTitle)
{
var pid = Process.GetCurrentProcess().Id;
var args = $"search --all --pid {pid} --class '.' set_window --name \"{newTitle}\"";
Process.Start("xdotool", args);
}
}
}
#endif

3
Assets/Plugins/Starpelly/OperatingSystem/Linux.cs.meta
View file

@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: 9e5d25ae0c3e4256abae4d2e07f7e14b
timeCreated: 1655775758

10
Assets/Plugins/Starpelly/OperatingSystem/MacOS.cs
View file

@ -1,10 +0,0 @@
namespace Starpelly.OperatingSystem
{
public class MacOS : IOperatingSystem
{
public void ChangeWindowTitle(string newTitle)
{
throw new System.NotImplementedException();
}
}
}

3
Assets/Plugins/Starpelly/OperatingSystem/MacOS.cs.meta
View file

@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: cfc6152d5db74f568b229047970f7889
timeCreated: 1655775758

58
Assets/Plugins/Starpelly/OperatingSystem/User32.cs
View file

@ -1,58 +0,0 @@
#if UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN
using System;
using System.Runtime.InteropServices;
using System.Text;
using Starpelly.Common;
using Starpelly.Enums.Windows;
namespace Starpelly.OperatingSystem
{
public class User32
{
#region Input
[DllImport("user32.dll", EntryPoint = "SetCursor")]
public static extern IntPtr SetCursor(IntPtr hCursor);
[DllImport("user32.dll", EntryPoint = "LoadCursor")]
public static extern IntPtr LoadCursor(IntPtr hInstance, int lpCursorName);
[DllImport("user32.dll", SetLastError = true)]
public static extern uint SendInput(uint numberOfInputs, INPUT[] inputs, int sizeOfInputStructure);
[DllImport("user32.dll")]
public static extern long SetCursorPos(int x, int y);
[DllImport("user32.dll")]
public static extern bool ClientToScreen(IntPtr hWnd, ref POINT point);
[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GetCursorPos(out POINT p);
[DllImport("user32.dll", SetLastError = true)]
public static extern uint SendInput(uint nInputs, ref INPUT pInputs, int cbSize);
[DllImport("user32.dll")]
public static extern IntPtr GetDesktopWindow();
[DllImport("user32.dll")]
public static extern IntPtr GetWindowDC(IntPtr ptr);
#endregion
#region Window
[DllImport("user32.dll", EntryPoint = "SetWindowText")]
public static extern bool SetWindowText(IntPtr hwnd, String lpString);
[DllImport("user32.dll", EntryPoint = "FindWindow")]
public static extern IntPtr FindWindow(String className, String windowName);
[DllImport("user32.dll")]
public static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int count);
[DllImport("user32.dll")]
public static extern IntPtr GetForegroundWindow();
#endregion
}
}
#endif

11
Assets/Plugins/Starpelly/OperatingSystem/User32.cs.meta
View file

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: eaea5ea9d5c881b4cb40464086c3a1da
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

141
Assets/Plugins/Starpelly/OperatingSystem/Windows.cs
View file

@ -1,141 +0,0 @@
#if UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN
using System;
using System.Runtime.InteropServices;
using Starpelly.Enums.Windows;
using System.Text;
namespace Starpelly.OperatingSystem
{
public class Windows : IOperatingSystem
{
/// <summary>
/// Gets the current title of the game window.
/// </summary>
/// <returns>The current title the window is, will probably only be used for changing the window in ChangeWindowTitle()</returns>
private static string GetActiveWindowTitle()
{
const int nChars = 256;
StringBuilder Buff = new StringBuilder(nChars);
IntPtr handle = User32.GetForegroundWindow();
if (User32.GetWindowText(handle, Buff, nChars) > 0)
{
return Buff.ToString();
}
return null;
}
/// <summary>
/// Changes the game's window title.
/// </summary>
/// <param name="newTitle">The title the window will be changed to.</param>
public void ChangeWindowTitle(string newTitle)
{
var windowPtr = User32.FindWindow(null, GetActiveWindowTitle());
User32.SetWindowText(windowPtr, newTitle);
}
#region Input
/// <summary>
/// Simulates a real key press passed in.
/// </summary>
public static void KeyPress(KeyCodeWin keyCode)
{
INPUT input = new INPUT
{
type = SendInputEventType.InputKeyboard,
mkhi = new MOUSEANDKEYBOARDINPUT
{
ki = new KEYBOARDINPUT
{
wVk = (ushort)keyCode,
wScan = 0,
dwFlags = 0, // if nothing, key down
time = 0,
dwExtraInfo = IntPtr.Zero,
}
}
};
INPUT input2 = new INPUT
{
type = SendInputEventType.InputKeyboard,
mkhi = new MOUSEANDKEYBOARDINPUT
{
ki = new KEYBOARDINPUT
{
wVk = (ushort)keyCode,
wScan = 0,
dwFlags = 2, // key up
time = 0,
dwExtraInfo = IntPtr.Zero,
}
}
};
INPUT[] inputs = new INPUT[] { input, input2 }; // Combined, it's a keystroke
User32.SendInput((uint)inputs.Length, inputs, Marshal.SizeOf(typeof(INPUT)));
}
/// <summary>
/// Sets your mouse pointer.
/// </summary>
public static void ChangeCursor(WindowsCursor cursor)
{
User32.SetCursor(User32.LoadCursor(IntPtr.Zero, (int)cursor));
}
/// <summary>
/// Immediately clicks the left mouse button.
/// </summary>
public static void ClickLeftMouseButton()
{
INPUT mouseDownInput = new INPUT();
mouseDownInput.type = SendInputEventType.InputMouse;
mouseDownInput.mkhi.mi.dwFlags = MouseEventFlags.MOUSEEVENT_LEFTDOWN;
User32.SendInput(1, ref mouseDownInput, Marshal.SizeOf(new INPUT()));
INPUT mouseUpInput = new INPUT();
mouseUpInput.type = SendInputEventType.InputMouse;
mouseUpInput.mkhi.mi.dwFlags = MouseEventFlags.MOUSEEVENT_LEFTUP;
User32.SendInput(1, ref mouseUpInput, Marshal.SizeOf(new INPUT()));
}
/// <summary>
/// Immediately clicks the right mouse button.
/// </summary>
public static void ClickRightMouseButton()
{
INPUT mouseDownInput = new INPUT();
mouseDownInput.type = SendInputEventType.InputMouse;
mouseDownInput.mkhi.mi.dwFlags = MouseEventFlags.MOUSEEVENT_RIGHTDOWN;
User32.SendInput(1, ref mouseDownInput, Marshal.SizeOf(new INPUT()));
INPUT mouseUpInput = new INPUT();
mouseUpInput.type = SendInputEventType.InputMouse;
mouseUpInput.mkhi.mi.dwFlags = MouseEventFlags.MOUSEEVENT_RIGHTUP;
User32.SendInput(1, ref mouseUpInput, Marshal.SizeOf(new INPUT()));
}
/// <summary>
/// Moves your cursor in the x and y params implemented, plus the current mouse pos.
/// </summary>
/// <param name="dx">Direction X</param>
/// <param name="dy">Direction Y</param>
public static void MouseMove(int dx, int dy)
{
INPUT mouseMove = new INPUT();
mouseMove.type = SendInputEventType.InputMouse;
mouseMove.mkhi.mi.dwFlags = MouseEventFlags.MOUSEEVENT_MOVE;
mouseMove.mkhi.mi.dx = dx;
mouseMove.mkhi.mi.dy = dy;
User32.SendInput(1, ref mouseMove, Marshal.SizeOf(new INPUT()));
}
#endregion
}
}
#endif

11
Assets/Plugins/Starpelly/OperatingSystem/Windows.cs.meta
View file

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: ad72bc489623a464780ec0ff75fe7d70
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

167
Assets/Plugins/Starpelly/Pelly.cs
View file

@ -1,167 +0,0 @@
namespace Pelly
{
public enum KeyCodeWin : ushort
{
#region Media
MEDIA_NEXT_TRACK = 0xb0,
MEDIA_PREV_TRACK = 0xb1,
MEDIA_STOP = 0xb2,
MEDIA_PLAY_PAUSE = 0xb3,
#endregion
#region Math Functions
MULTIPLY = 0x6a, // '*'
ADD = 0x6b,
SUBTRACT = 0x6d,
DIVIDE = 0x6f,
#endregion
#region Browser
BROWSER_BACK = 0xa6,
BROWSER_FORWARD = 0xa7,
BROWSER_REFRESH = 0xa8,
BROWSER_STOP = 0xa9,
BROWSER_SEARCH = 0xaa,
BROWSER_FAVORITES = 0xab,
BROWSER_HOME = 0xac,
#endregion
#region Numpad numbers
NUMPAD0 = 0x60,
NUMPAD1 = 0x61,
NUMPAD2 = 0x62,
NUMPAD3 = 0x63,
NUMPAD4 = 0x64, // 100
NUMPAD5 = 0x65,
NUMPAD6 = 0x66,
NUMPAD7 = 0x67,
NUMPAD8 = 0x68,
NUMPAD9 = 0x69,
#endregion
#region Function Keys
F1 = 0x70,
F2 = 0x71,
F3 = 0x72,
F4 = 0x73,
F5 = 0x74,
F6 = 0x75,
F7 = 0x76,
F8 = 0x77,
F9 = 0x78,
F10 = 0x79,
F11 = 0x7a,
F12 = 0x7b,
F13 = 0x7c,
F14 = 0x7d,
F15 = 0x7e,
F16 = 0x7f,
F17 = 0x80,
F18 = 0x81,
F19 = 130,
F20 = 0x83,
F21 = 0x84,
F22 = 0x85,
F23 = 0x86,
F24 = 0x87,
#endregion
#region Other
// see https://lists.w3.org/Archives/Public/www-dom/2010JulSep/att-0182/keyCode-spec.html
OEM_COLON = 0xba, // OEM_1
OEM_102 = 0xe2,
OEM_2 = 0xbf,
OEM_3 = 0xc0,
OEM_4 = 0xdb,
OEM_BACK_SLASH = 0xdc, // OEM_5
OEM_6 = 0xdd,
OEM_7 = 0xde,
OEM_8 = 0xdf,
OEM_CLEAR = 0xfe,
OEM_COMMA = 0xbc,
OEM_MINUS = 0xbd, // Underscore
OEM_PERIOD = 0xbe,
OEM_PLUS = 0xbb,
#endregion
#region KEYS
KEY_0 = 0x30,
KEY_1 = 0x31,
KEY_2 = 0x32,
KEY_3 = 0x33,
KEY_4 = 0x34,
KEY_5 = 0x35,
KEY_6 = 0x36,
KEY_7 = 0x37,
KEY_8 = 0x38,
KEY_9 = 0x39,
KEY_A = 0x41,
KEY_B = 0x42,
KEY_C = 0x43,
KEY_D = 0x44,
KEY_E = 0x45,
KEY_F = 0x46,
KEY_G = 0x47,
KEY_H = 0x48,
KEY_I = 0x49,
KEY_J = 0x4a,
KEY_K = 0x4b,
KEY_L = 0x4c,
KEY_M = 0x4d,
KEY_N = 0x4e,
KEY_O = 0x4f,
KEY_P = 0x50,
KEY_Q = 0x51,
KEY_R = 0x52,
KEY_S = 0x53,
KEY_T = 0x54,
KEY_U = 0x55,
KEY_V = 0x56,
KEY_W = 0x57,
KEY_X = 0x58,
KEY_Y = 0x59,
KEY_Z = 0x5a,
#endregion
#region volume
VOLUME_MUTE = 0xad,
VOLUME_DOWN = 0xae,
VOLUME_UP = 0xaf,
#endregion
SNAPSHOT = 0x2c,
RIGHT_CLICK = 0x5d,
BACKSPACE = 8,
CANCEL = 3,
CAPS_LOCK = 20,
CONTROL = 0x11,
ALT = 18,
DECIMAL = 110,
DELETE = 0x2e,
DOWN = 40,
END = 0x23,
ESC = 0x1b,
HOME = 0x24,
INSERT = 0x2d,
LAUNCH_APP1 = 0xb6,
LAUNCH_APP2 = 0xb7,
LAUNCH_MAIL = 180,
LAUNCH_MEDIA_SELECT = 0xb5,
LCONTROL = 0xa2,
LEFT = 0x25,
LSHIFT = 0xa0,
LWIN = 0x5b,
PAGEDOWN = 0x22,
NUMLOCK = 0x90,
PAGE_UP = 0x21,
RCONTROL = 0xa3,
ENTER = 13,
RIGHT = 0x27,
RSHIFT = 0xa1,
RWIN = 0x5c,
SHIFT = 0x10,
SPACE_BAR = 0x20,
TAB = 9,
UP = 0x26,
}
}

11
Assets/Plugins/Starpelly/Pelly.cs.meta
View file

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 270c0104ad1fee346ac2cd6cdc617329
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Plugins/Starpelly/Properties.meta
View file

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 20020e40c9650d34a938ffef9aa986cf
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

13
Assets/Plugins/Starpelly/Properties/Arrays.cs
View file

@ -1,13 +0,0 @@
using System;
namespace Starpelly.Properties
{
public static class Arrays
{
public static void Push<T>(ref T[] table, object value)
{
Array.Resize(ref table, table.Length + 1);
table.SetValue(value, table.Length - 1);
}
}
}

11
Assets/Plugins/Starpelly/Properties/Arrays.cs.meta
View file

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: f44e2d87a27b15847b56b14db8a25730
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

56
Assets/Plugins/Starpelly/Properties/Strings.cs
View file

@ -1,56 +0,0 @@
using Starpelly.Enums.Strings;
namespace Starpelly.Properties
{
public class Strings
{
/// <summary>
/// Chooses a string based on the StringType chosen.
/// </summary>
/// <param name="stringType">The string type eg. (uppercase, lowercase, numeric)</param>
/// <returns>A list of chars because enums don't support strings. :(</returns>
public static string Chars(StringType stringType)
{
const string alpha = @"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
const string numeric = @"0123456789";
const string alphanumeric = @"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
const string uppercase = @"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const string lowercase = @"abcdefghijklmnopqrstuvwxyz";
const string punctuation = @"!@#$%^&*()_+{}:|<>?/.,;'\[]-=`~ ";
const string all = @"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()_+{}:|<>?/.,;'\[]-=`~ ";
string returnString;
// I wish C# had the ability to use strings with enums
switch (stringType)
{
case StringType.Alpha:
returnString = alpha;
break;
case StringType.Numeric:
returnString = numeric;
break;
case StringType.Alphanumeric:
returnString = alphanumeric;
break;
case StringType.Uppercase:
returnString = uppercase;
break;
case StringType.Lowercase:
returnString = lowercase;
break;
case StringType.Punctuation:
returnString = punctuation;
break;
case StringType.ALL:
returnString = all;
break;
default:
returnString = all;
break;
}
return returnString;
}
}
}

11
Assets/Plugins/Starpelly/Properties/Strings.cs.meta
View file

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: bbc057365bf984546b564868d853a53a
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

30
Assets/Plugins/Starpelly/README.md
View file

@ -1,30 +0,0 @@
# Starpelly
Tools for Unity
Simulates the "A" key press every 0.6 seconds:
```cs
using UnityEngine;
using Starpelly.OS;
public class test : MonoBehaviour
{
private float action = 0.0f;
private float period = 0.6f;
private void Start()
{
Application.runInBackground = true;
}
private void Update()
{
if (Time.time > action)
{
action += period;
Windows.KeyPress(Starpelly.KeyCodeWin.KEY_A);
}
}
}
```

7
Assets/Plugins/Starpelly/README.md.meta
View file

@ -1,7 +0,0 @@
fileFormatVersion: 2
guid: 420b909aa281dcb478854d7bbba95ebf
TextScriptImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

25
Assets/Plugins/Starpelly/Random.cs
View file

@ -1,25 +0,0 @@
using System.Linq;
using Starpelly.Enums.Strings;
namespace Starpelly.Random
{
public class Strings
{
private static System.Random random = new System.Random();
/// <summary>
/// Function used to get a random string using the StringType and length provided.
/// </summary>
/// <param name="stringType">The string type. e.g, (uppercase, lowercase, numeric)</param>
/// <param name="length">The length you want the string to be.</param>
/// <returns>A random string of characters in a random order.</returns>
public static string RandomString(StringType stringType, int length)
{
string chars = Properties.Strings.Chars(stringType);
return new string(Enumerable.Repeat(chars, length)
.Select(s => s[random.Next(s.Length)]).ToArray());
}
}
}

11
Assets/Plugins/Starpelly/Random.cs.meta
View file

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 2c01318b4f5f869499a36b5d80319b47
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

62
Assets/Plugins/Starpelly/RendererExtensions.cs
View file

@ -1,62 +0,0 @@
using UnityEngine;
public static class RendererExtensions
{
/// <summary>
/// Counts the bounding box corners of the given RectTransform that are visible from the given Camera in screen space.
/// </summary>
/// <returns>The amount of bounding box corners that are visible from the Camera.</returns>
/// <param name="rectTransform">Rect transform.</param>
/// <param name="camera">Camera.</param>
private static int CountCornersVisibleFrom(this RectTransform rectTransform, Camera camera)
{
Rect screenBounds = new Rect(0f, 0f, Screen.width, Screen.height); // Screen space bounds (assumes camera renders across the entire screen)
Vector3[] objectCorners = new Vector3[4];
rectTransform.GetWorldCorners(objectCorners);
int visibleCorners = 0;
Vector3 tempScreenSpaceCorner; // Cached
for (var i = 0; i < objectCorners.Length; i++) // For each corner in rectTransform
{
tempScreenSpaceCorner = camera.WorldToScreenPoint(objectCorners[i]); // Transform world space position of corner to screen space
if (screenBounds.Contains(tempScreenSpaceCorner)) // If the corner is inside the screen
{
visibleCorners++;
}
}
return visibleCorners;
}
/// <summary>
/// Determines if this RectTransform is fully visible from the specified camera.
/// Works by checking if each bounding box corner of this RectTransform is inside the cameras screen space view frustrum.
/// </summary>
/// <returns><c>true</c> if is fully visible from the specified camera; otherwise, <c>false</c>.</returns>
/// <param name="rectTransform">Rect transform.</param>
/// <param name="camera">Camera.</param>
public static bool IsFullyVisibleFrom(this RectTransform rectTransform, Camera camera)
{
return CountCornersVisibleFrom(rectTransform, camera) == 4; // True if all 4 corners are visible
}
/// <summary>
/// Determines if this RectTransform is at least partially visible from the specified camera.
/// Works by checking if any bounding box corner of this RectTransform is inside the cameras screen space view frustrum.
/// </summary>
/// <returns><c>true</c> if is at least partially visible from the specified camera; otherwise, <c>false</c>.</returns>
/// <param name="rectTransform">Rect transform.</param>
/// <param name="camera">Camera.</param>
public static bool IsVisibleFrom(this RectTransform rectTransform, Camera camera)
{
return CountCornersVisibleFrom(rectTransform, camera) > 0; // True if any corners are visible
}
public static bool MouseIsWithin(this RectTransform rectTransform)
{
var normalizedMousePosition = new Vector2(Input.mousePosition.x / Screen.width, Input.mousePosition.y / Screen.height);
return normalizedMousePosition.x > rectTransform.anchorMin.x &&
normalizedMousePosition.x < rectTransform.anchorMax.x &&
normalizedMousePosition.y > rectTransform.anchorMin.y &&
normalizedMousePosition.y < rectTransform.anchorMax.y;
}
}

11
Assets/Plugins/Starpelly/RendererExtensions.cs.meta
View file

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: e8273052806a5334cbf581670753ee77
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

111
Assets/Plugins/Starpelly/ScreenUtility.cs
View file

@ -1,111 +0,0 @@
using UnityEngine;
public static class ScreenUtility
{
public static Camera camera;
public static float Left
{
get
{
if (camera)
return camera.ViewportToWorldPoint(new Vector3(0f, 0f, 0f)).x;
if (Camera.main)
return Camera.main.ViewportToWorldPoint(new Vector3(0f, 0f, 0f)).x;
return 0.0f;
}
}
public static float Right
{
get
{
if (camera)
return camera.ViewportToWorldPoint(new Vector3(1.0f, 0f, 0f)).x;
if (Camera.main)
return Camera.main.ViewportToWorldPoint(new Vector3(1.0f, 0f, 0f)).x;
return 0.0f;
}
}
public static float Top
{
get
{
if (camera)
return camera.ViewportToWorldPoint(new Vector3(0f, 1.0f, 0f)).y;
if (Camera.main)
return Camera.main.ViewportToWorldPoint(new Vector3(0f, 1.0f, 0f)).y;
return 0.0f;
}
}
public static float Bottom
{
get
{
if (camera)
return camera.ViewportToWorldPoint(new Vector3(0f, 0f, 0f)).y;
if (Camera.main)
return Camera.main.ViewportToWorldPoint(new Vector3(0f, 0f, 0f)).y;
return 0.0f;
}
}
public static Vector3 Center
{
get
{
if (camera)
return camera.ViewportToWorldPoint(new Vector3(0.5f, 0.5f, 0f));
if (Camera.main)
return Camera.main.ViewportToWorldPoint(new Vector3(0.5f, 0.5f, 0f));
return Vector3.zero;
}
}
public static bool ScreenContainsPoint(Vector3 worldPosition)
{
return Camera.main.rect.Contains(Camera.main.WorldToViewportPoint(worldPosition));
}
public static void ConstrainCamera(Camera camera, Bounds bounds)
{
float left = camera.ViewportToWorldPoint(new Vector3(0f, 0f, 0f)).x;
float right = camera.ViewportToWorldPoint(new Vector3(1.0f, 0f, 0f)).x;
float top = camera.ViewportToWorldPoint(new Vector3(0f, 1.0f, 0f)).y;
float bottom = camera.ViewportToWorldPoint(new Vector3(0f, 0f, 0f)).y;
if (top > bounds.max.y)
{
float topDiff = bounds.max.y - top;
camera.transform.position += new Vector3(0, topDiff, 0);
}
else if (bottom < bounds.min.y)
{
float botDiff = bounds.min.y - bottom;
camera.transform.position += new Vector3(0, botDiff, 0);
}
if (right > bounds.max.x)
{
float rightDiff = bounds.max.x - right;
camera.transform.position += new Vector3(rightDiff, 0, 0);
}
else if (left < bounds.min.x)
{
float leftDiff = bounds.min.x - left;
camera.transform.position += new Vector3(leftDiff, 0, 0);
}
}
}

11
Assets/Plugins/Starpelly/ScreenUtility.cs.meta
View file

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 8ef77a2b31ced114793835fcc91d9e34
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Plugins/Starpelly/Shaders.meta
View file

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: f189f8c5d2787e84694d7f3a2be16a20
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Plugins/Starpelly/Shaders/Blend Modes.meta
View file

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 0ad209f05754ddf4a96bf4e0e02b9228
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/Add.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/Add"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = Add(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/Add.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 0ae724cf80d801b43b140517e4bbb12f
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Plugins/Starpelly/Shaders/Blend Modes/CGIncludes.meta
View file

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: edc6b21aef727c14bb42932e92c7be29
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

233
Assets/Plugins/Starpelly/Shaders/Blend Modes/CGIncludes/PhotoshopBlendModes.cginc
View file

@ -1,233 +0,0 @@
#ifndef PHOTOSHOP_BLENDMODES_INCLUDED
#define PHOTOSHOP_BLENDMODES_INCLUDED
//
// Ported from https://www.shadertoy.com/view/XdS3RW
//
// Original License:
//
// Creative Commons CC0 1.0 Universal (CC-0)
//
// 25 of the layer blending modes from Photoshop.
//
// The ones I couldn't figure out are from Nvidia's advanced blend equations extension spec -
// http://www.opengl.org/registry/specs/NV/blend_equation_advanced.txt
//
// ~bj.2013
//
// Helpers
const fixed3 l = fixed3(0.3, 0.59, 0.11);
/** @private */
float pinLight(float s, float d)
{
return (2.0*s - 1.0 > d) ? 2.0*s - 1.0 : (s < 0.5 * d) ? 2.0*s : d;
}
/** @private */
float vividLight(float s, float d)
{
return (s < 0.5) ? 1.0 - (1.0 - d) / (2.0 * s) : d / (2.0 * (1.0 - s));
}
/** @private */
float hardLight(float s, float d)
{
return (s < 0.5) ? 2.0*s*d : 1.0 - 2.0*(1.0 - s)*(1.0 - d);
}
/** @private */
float softLight(float s, float d)
{
return (s < 0.5) ? d - (1.0 - 2.0*s)*d*(1.0 - d)
: (d < 0.25) ? d + (2.0*s - 1.0)*d*((16.0*d - 12.0)*d + 3.0)
: d + (2.0*s - 1.0) * (sqrt(d) - d);
}
/** @private */
float overlay( float s, float d )
{
return (d < 0.5) ? 2.0*s*d : 1.0 - 2.0*(1.0 - s)*(1.0 - d);
}
// rgb<-->hsv functions by Sam Hocevar
// http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl
/** @private */
fixed3 rgb2hsv(fixed3 c)
{
fixed4 K = fixed4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
fixed4 p = lerp(fixed4(c.bg, K.wz), fixed4(c.gb, K.xy), step(c.b, c.g));
fixed4 q = lerp(fixed4(p.xyw, c.r), fixed4(c.r, p.yzx), step(p.x, c.r));
float d = q.x - min(q.w, q.y);
float e = 1.0e-10;
return fixed3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
}
/** @private */
fixed3 hsv2rgb(fixed3 c)
{
fixed4 K = fixed4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
fixed3 p = abs(frac(c.xxx + K.xyz) * 6.0 - K.www);
return c.z * lerp(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
}
// Public API Blend Modes
fixed3 ColorBurn(fixed3 s, fixed3 d)
{
return 1.0 - (1.0 - d) / s;
}
fixed3 LinearBurn(fixed3 s, fixed3 d )
{
return s + d - 1.0;
}
fixed3 DarkerColor(fixed3 s, fixed3 d)
{
return (s.x + s.y + s.z < d.x + d.y + d.z) ? s : d;
}
fixed3 Lighten(fixed3 s, fixed3 d)
{
return max(s, d);
}
fixed3 Screen(fixed3 s, fixed3 d)
{
return s + d - s * d;
}
fixed3 ColorDodge(fixed3 s, fixed3 d)
{
return d / (1.0 - s);
}
fixed3 LinearDodge(fixed3 s, fixed3 d)
{
return s + d;
}
fixed3 LighterColor(fixed3 s, fixed3 d)
{
return (s.x + s.y + s.z > d.x + d.y + d.z) ? s : d;
}
fixed3 Overlay(fixed3 s, fixed3 d)
{
fixed3 c;
c.x = overlay(s.x, d.x);
c.y = overlay(s.y, d.y);
c.z = overlay(s.z, d.z);
return c;
}
fixed3 SoftLight(fixed3 s, fixed3 d)
{
fixed3 c;
c.x = softLight(s.x, d.x);
c.y = softLight(s.y, d.y);
c.z = softLight(s.z, d.z);
return c;
}
fixed3 HardLight(fixed3 s, fixed3 d)
{
fixed3 c;
c.x = hardLight(s.x, d.x);
c.y = hardLight(s.y, d.y);
c.z = hardLight(s.z, d.z);
return c;
}
fixed3 VividLight(fixed3 s, fixed3 d)
{
fixed3 c;
c.x = vividLight(s.x, d.x);
c.y = vividLight(s.y, d.y);
c.z = vividLight(s.z, d.z);
return c;
}
fixed3 LinearLight(fixed3 s, fixed3 d)
{
return 2.0*s + d - 1.0;
}
fixed3 PinLight(fixed3 s, fixed3 d)
{
fixed3 c;
c.x = pinLight(s.x, d.x);
c.y = pinLight(s.y, d.y);
c.z = pinLight(s.z, d.z);
return c;
}
fixed3 HardMix(fixed3 s, fixed3 d)
{
return floor(s+d);
}
fixed3 Difference(fixed3 s, fixed3 d)
{
return abs(d-s);
}
fixed3 Exclusion(fixed3 s, fixed3 d)
{
return s + d - 2.0*s*d;
}
fixed3 Subtract(fixed3 s, fixed3 d)
{
return s-d;
}
fixed3 Divide(fixed3 s, fixed3 d)
{
return s/d;
}
fixed3 Add(fixed3 s, fixed3 d)
{
return s+d;
}
fixed3 Hue(fixed3 s, fixed3 d)
{
d = rgb2hsv(d);
d.x = rgb2hsv(s).x;
return hsv2rgb(d);
}
fixed3 Color(fixed3 s, fixed3 d)
{
s = rgb2hsv(s);
s.z = rgb2hsv(d).z;
return hsv2rgb(s);
}
fixed3 Saturation(fixed3 s, fixed3 d)
{
d = rgb2hsv(d);
d.y = rgb2hsv(s).y;
return hsv2rgb(d);
}
fixed3 Luminosity(fixed3 s, fixed3 d)
{
float dLum = dot(d, l);
float sLum = dot(s, l);
float lum = sLum - dLum;
fixed3 c = d + lum;
float minC = min(min(c.x, c.y), c.z);
float maxC = max(max(c.x, c.y), c.z);
if(minC < 0.0) return sLum + ((c - sLum) * sLum) / (sLum - minC);
else if(maxC > 1.0) return sLum + ((c - sLum) * (1.0 - sLum)) / (maxC - sLum);
else return c;
}
#endif // PHOTOSHOP_BLENDMODES_INCLUDED

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/CGIncludes/PhotoshopBlendModes.cginc.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: eb4ec4a0e81584343b972b2a25f96bc2
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/Color.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/Color"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = Color(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/Color.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: bb85841f8c67d2442b800ab4be4ecae5
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/ColorBurn.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/ColorBurn"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = ColorBurn(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/ColorBurn.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: da5b85daa127ed043af5579d10e6e49d
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/ColorDodge.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/ColorDodge"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = ColorDodge(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/ColorDodge.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: a1c1848ac45b3724483467a3f2f10326
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/DarkerColor.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/DarkerColor"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = DarkerColor(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/DarkerColor.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: d0090e6d378db134baa8c6bf62a4a607
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/Difference.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/Difference"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = Difference(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/Difference.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 74ccff3d254d9644fa54c55127b3646d
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/Divide.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/Divide"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = Divide(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/Divide.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 075fe556031b1174e8d6ca9369753b6d
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/Exclusion.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/Exclusion"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = Exclusion(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/Exclusion.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: d292d32bbf4832745a23aa6a3a06b1de
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/HardLight.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/HardLight"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = HardLight(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/HardLight.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: fe63576204204b1428a23c825667e2a9
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/HardMix.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/HardMix"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = HardMix(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/HardMix.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 4dc9a51c26a36e044904b7e3a5a87c51
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/Hue.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/Hue"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = Hue(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/Hue.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: ac709b7b6ba995046b2e357657ce6e8a
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/Lighten.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/Lighten"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = Lighten(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/Lighten.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: af52445a55f450d488ad19f3f0f7b2c6
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/LighterColor.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/LighterColor"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = LighterColor(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/LighterColor.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 8c3ff3424a6646142b77fd44709ac344
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/LinearBurn.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/LinearBurn"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = LinearBurn(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/LinearBurn.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 0cce16f4622c09c47918eeaa45e90221
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/LinearDodge.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/LinearDodge"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = LinearDodge(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/LinearDodge.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 57c2408124f76304286601e694c90cd9
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/LinearLight.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/LinearLight"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = LinearLight(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/LinearLight.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: b2d75a74e3683154db45a2a4191be880
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/Luminosity.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/Luminosity"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = Luminosity(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/Luminosity.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: fce1c8cc491cb9949990727c4b160df1
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/Overlay.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/Overlay"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = Overlay(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/Overlay.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 2ffc151e4b55f1e468e1a7fd115dc8f8
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/PinLight.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/PinLight"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = PinLight(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/PinLight.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: f78ab9a11343ac647b0fd6e24af945df
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/Saturation.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/Saturation"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = Saturation(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/Saturation.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 9da612291cb24ba4f8ed18d8ad9ab609
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/Screen.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/Screen"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = Screen(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/Screen.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 2b7011eeda59694449ddcd78ad15ba20
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/SoftLight.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/SoftLight"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = SoftLight(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/SoftLight.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 9c5c0203c153de344acd602adb1210bb
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/Subtract.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/Subtract"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = Subtract(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/Subtract.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: dad2fab4a5cb39846a52481a503e6d11
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Plugins/Starpelly/Shaders/Blend Modes/VividLight.shader
View file

@ -1,106 +0,0 @@
Shader "Blendmodes/VividLight"
{
Properties
{
[Header(Properties)]
_MainTex ("Blend Texture", 2D) = "white" {}
_Tint1 ("Tint on Texture", Color) = (1,1,1,0)
_Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
_Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
//blending
[Header(Blending)]
[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
// required for UI.Mask
[Header(Stencil)]
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
_Stencil ("Stencil ID", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
_StencilWriteMask ("Stencil Write Mask", Float) = 255
_StencilReadMask ("Stencil Read Mask", Float) = 255
[Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
LOD 100
Blend [_BlendSrc] [_BlendDst]
// required for UI.Mask
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
GrabPass
{
"_BackgroundTexture"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
#include "CGIncludes/PhotoshopBlendModes.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
float2 bguv : TEXCOORD1;
};
sampler2D _MainTex;
fixed4 _MainTex_ST;
fixed4 _Tint1;
fixed4 _Tint2;
fixed _Alpha;
sampler2D _BackgroundTexture;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
o.color = v.color;
o.bguv = ComputeGrabScreenPos(o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 mainColor = tex2D(_BackgroundTexture, i.bguv);
fixed4 blendColor = tex2D(_MainTex, i.uv) * i.color;
blendColor.xyz += _Tint1.xyz * _Tint1.a;
// perform blend
mainColor.xyz = VividLight(mainColor.xyz, blendColor.xyz);
mainColor.xyz += _Tint2.xyz * _Tint2.a;
mainColor.a = blendColor.a * _Alpha;
return mainColor;
}
ENDCG
}
}
}

9
Assets/Plugins/Starpelly/Shaders/Blend Modes/VividLight.shader.meta
View file

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: bef33988c68cc854780ec0424181377e
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

167
Assets/Plugins/Starpelly/Starpelly.cs
View file

@ -1,167 +0,0 @@
namespace Starpelly
{
public enum KeyCodeWin : ushort
{
#region Media
MEDIA_NEXT_TRACK = 0xb0,
MEDIA_PREV_TRACK = 0xb1,
MEDIA_STOP = 0xb2,
MEDIA_PLAY_PAUSE = 0xb3,
#endregion
#region Math Functions
MULTIPLY = 0x6a, // '*'
ADD = 0x6b,
SUBTRACT = 0x6d,
DIVIDE = 0x6f,
#endregion
#region Browser
BROWSER_BACK = 0xa6,
BROWSER_FORWARD = 0xa7,
BROWSER_REFRESH = 0xa8,
BROWSER_STOP = 0xa9,
BROWSER_SEARCH = 0xaa,
BROWSER_FAVORITES = 0xab,
BROWSER_HOME = 0xac,
#endregion
#region Numpad numbers
NUMPAD0 = 0x60,
NUMPAD1 = 0x61,
NUMPAD2 = 0x62,
NUMPAD3 = 0x63,
NUMPAD4 = 0x64, // 100
NUMPAD5 = 0x65,
NUMPAD6 = 0x66,
NUMPAD7 = 0x67,
NUMPAD8 = 0x68,
NUMPAD9 = 0x69,
#endregion
#region Function Keys
F1 = 0x70,
F2 = 0x71,
F3 = 0x72,
F4 = 0x73,
F5 = 0x74,
F6 = 0x75,
F7 = 0x76,
F8 = 0x77,
F9 = 0x78,
F10 = 0x79,
F11 = 0x7a,
F12 = 0x7b,
F13 = 0x7c,
F14 = 0x7d,
F15 = 0x7e,
F16 = 0x7f,
F17 = 0x80,
F18 = 0x81,
F19 = 130,
F20 = 0x83,
F21 = 0x84,
F22 = 0x85,
F23 = 0x86,
F24 = 0x87,
#endregion
#region Other
// see https://lists.w3.org/Archives/Public/www-dom/2010JulSep/att-0182/keyCode-spec.html
OEM_COLON = 0xba, // OEM_1
OEM_102 = 0xe2,
OEM_2 = 0xbf,
OEM_3 = 0xc0,
OEM_4 = 0xdb,
OEM_BACK_SLASH = 0xdc, // OEM_5
OEM_6 = 0xdd,
OEM_7 = 0xde,
OEM_8 = 0xdf,
OEM_CLEAR = 0xfe,
OEM_COMMA = 0xbc,
OEM_MINUS = 0xbd, // Underscore
OEM_PERIOD = 0xbe,
OEM_PLUS = 0xbb,
#endregion
#region KEYS
KEY_0 = 0x30,
KEY_1 = 0x31,
KEY_2 = 0x32,
KEY_3 = 0x33,
KEY_4 = 0x34,
KEY_5 = 0x35,
KEY_6 = 0x36,
KEY_7 = 0x37,
KEY_8 = 0x38,
KEY_9 = 0x39,
KEY_A = 0x41,
KEY_B = 0x42,
KEY_C = 0x43,
KEY_D = 0x44,
KEY_E = 0x45,
KEY_F = 0x46,
KEY_G = 0x47,
KEY_H = 0x48,
KEY_I = 0x49,
KEY_J = 0x4a,
KEY_K = 0x4b,
KEY_L = 0x4c,
KEY_M = 0x4d,
KEY_N = 0x4e,
KEY_O = 0x4f,
KEY_P = 0x50,
KEY_Q = 0x51,
KEY_R = 0x52,
KEY_S = 0x53,
KEY_T = 0x54,
KEY_U = 0x55,
KEY_V = 0x56,
KEY_W = 0x57,
KEY_X = 0x58,
KEY_Y = 0x59,
KEY_Z = 0x5a,
#endregion
#region volume
VOLUME_MUTE = 0xad,
VOLUME_DOWN = 0xae,
VOLUME_UP = 0xaf,
#endregion
SNAPSHOT = 0x2c,
RIGHT_CLICK = 0x5d,
BACKSPACE = 8,
CANCEL = 3,
CAPS_LOCK = 20,
CONTROL = 0x11,
ALT = 18,
DECIMAL = 110,
DELETE = 0x2e,
DOWN = 40,
END = 0x23,
ESC = 0x1b,
HOME = 0x24,
INSERT = 0x2d,
LAUNCH_APP1 = 0xb6,
LAUNCH_APP2 = 0xb7,
LAUNCH_MAIL = 180,
LAUNCH_MEDIA_SELECT = 0xb5,
LCONTROL = 0xa2,
LEFT = 0x25,
LSHIFT = 0xa0,
LWIN = 0x5b,
PAGEDOWN = 0x22,
NUMLOCK = 0x90,
PAGE_UP = 0x21,
RCONTROL = 0xa3,
ENTER = 13,
RIGHT = 0x27,
RSHIFT = 0xa1,
RWIN = 0x5c,
SHIFT = 0x10,
SPACE_BAR = 0x20,
TAB = 9,
UP = 0x26,
}
}

11
Assets/Plugins/Starpelly/Starpelly.cs.meta
View file

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 064d99289dbc58041b5102296a64ab2d
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

21
Assets/Plugins/Starpelly/Textures.cs
View file

@ -1,21 +0,0 @@
using UnityEngine;
namespace Starpelly.Textures
{
public static class Draw
{
public static void DrawLine(this Texture2D tex, Vector2 p1, Vector2 p2, Color col)
{
Vector2 t = p1;
float frac = 1 / Mathf.Sqrt(Mathf.Pow(p2.x - p1.x, 2) + Mathf.Pow(p2.y - p1.y, 2));
float ctr = 0;
while ((int)t.x != (int)p2.x || (int)t.y != (int)p2.y)
{
t = Vector2.Lerp(p1, p2, ctr);
ctr += frac;
tex.SetPixel((int)t.x, (int)t.y, col);
}
}
}
}

Some files were not shown because too many files have changed in this diff Show more