Merge branch 'Melioli-main'

Assets/Shaders/PrimoToon-main.hlsl → PrimoToon-main.hlsl

@@ -699,4 +699,4 @@ vector<fixed, 4> frag(vsOut i, bool frontFacing : SV_IsFrontFace) : SV_Target{
     /* END OF DEBUGGING */
 
     return finalColor;
-}
+}

Scripts/ThryEditor/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

Scripts/ThryEditor/CREDITS.txt

@@ -0,0 +1,6 @@
+Shader Optimizer : Kaj (https://github.com/DarthShader)
+sRGBWarningDrawer : z3y (https://github.com/z3y)
+Auto Anchor Feature : Pumkin (https://github.com/rurre)
+
+Shader Optimizer - Property Renaming : RequiDev (https://github.com/RequiDev)
+Shader Optimizer - Shared Locked Shaders : 3 (https://github.com/Float3)

Scripts/ThryEditor/Editor/ChannelPreview.shader

@@ -0,0 +1,64 @@
+Shader "Hidden/Thry/ChannelPreview"
+{
+    Properties
+    {
+        _MainTex ("Texture", 2D) = "white" {}
+        _Channel ("Channel", Float) = 0.0
+    }
+    SubShader
+    {
+        Tags { "RenderType"="Transparent" }
+        LOD 100
+
+        Pass
+        {
+            CGPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+
+            #include "UnityCG.cginc"
+
+            struct appdata
+            {
+                float4 vertex : POSITION;
+                float2 uv : TEXCOORD0;
+            };
+
+            struct v2f
+            {
+                float2 uv : TEXCOORD0;
+                float4 vertex : SV_POSITION;
+            };
+
+            sampler2D _MainTex;
+            float4 _MainTex_ST;
+            float _Channel;
+
+            v2f vert (appdata v)
+            {
+                v2f o;
+                o.vertex = UnityObjectToClipPos(v.vertex);
+                o.uv = v.uv;
+                return o;
+            }
+
+            fixed4 frag (v2f i) : SV_Target
+            {
+                // sample the texture
+                fixed4 col = tex2D(_MainTex, i.uv);
+                if(_Channel == -1.0) return fixed4(col.r, col.g, col.b, col.a);
+                if(_Channel == 0.0) return fixed4(col.r, 0, 0, 1);
+                if(_Channel == 1.0) return fixed4(0, col.g, 0, 1);
+                if(_Channel == 2.0) return fixed4(0, 0, col.b, 1);
+                if(_Channel == 3.0) return fixed4(col.a, col.a, col.a, 1);
+                if(_Channel == 4.0)
+                {
+                    float val = max(col.r, max(col.g, col.b));
+                    return fixed4(val, val, val, 1);
+                }
+                return fixed4(0, 0, 0, 1);
+            }
+            ENDCG
+        }
+    }
+}

Scripts/ThryEditor/Editor/Config.cs

@@ -0,0 +1,199 @@
+// Material/Shader Inspector for Unity 2017/2018
+// Copyright (C) 2019 Thryrallo
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Globalization;
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace Thry
+{
+    public class Config
+    {
+        // consts
+        private const string PATH_CONFIG_FILE = "Thry/Config.json";
+        private const string VERSION = "2.42.2";
+
+        // static
+        private static Config config;
+
+        public static void OnCompile()
+        {
+            if (!File.Exists(PATH_CONFIG_FILE))
+            {
+                //Settings.firstTimePopup();
+            }
+            else
+            {
+                string prevVersion = Singleton.verion;
+                string installedVersion = VERSION;
+                int versionComparision = Helper.CompareVersions(installedVersion, prevVersion);
+                if (versionComparision != 0)
+                {
+                    config.verion = VERSION;
+                    config.Save();
+                }
+                if (versionComparision == 1)
+                {
+                    Settings.updatedPopup(versionComparision);
+                }
+                else if (versionComparision == -1)
+                {
+                    config.OnUpgrade(prevVersion);
+                    Debug.Log(">>> Thry Editor has been updated to version " + installedVersion);
+                }
+            }
+        }
+
+        public static Config Singleton
+        {
+            get
+            {
+                if (config == null)
+                {
+                    if (File.Exists(PATH_CONFIG_FILE))
+                        config = JsonUtility.FromJson<Config>(FileHelper.ReadFileIntoString(PATH_CONFIG_FILE));
+                    else
+                        config = new Config().Save();
+                }
+                return config;
+            }
+        }
+
+        //actual config class
+        public TextureDisplayType default_texture_type = TextureDisplayType.small;
+        public bool showRenderQueue = true;
+        public bool showManualReloadButton = false;
+        public bool allowCustomLockingRenaming = false;
+        public bool autoMarkPropertiesAnimated = true;
+        public TextureImporterFormat texturePackerCompressionWithAlphaOverwrite = TextureImporterFormat.Automatic;
+        public TextureImporterFormat texturePackerCompressionNoAlphaOverwrite = TextureImporterFormat.Automatic;
+        public TextureImporterFormat gradientEditorCompressionOverwrite = TextureImporterFormat.Automatic;
+
+        public string locale = "English";
+
+        public string gradient_name = "gradient_<hash>.png";
+
+        public bool autoSetAnchorOverride = true;
+        public HumanBodyBones humanBoneAnchor = HumanBodyBones.Spine;
+        public string anchorOverrideObjectName = "AutoAnchorObject";
+        public bool autoSetAnchorAskedOnce = false;
+        public bool enableDeveloperMode = false;
+        public bool disableUnlockedShaderStrippingOnBuild = false;
+        public bool forceAsyncCompilationPreview = true;
+        public bool fixKeywordsWhenLocking = true;
+        public bool saveAfterLockUnlock = true;
+
+        public string verion = VERSION;
+
+        public Config Save()
+        {
+            FileHelper.WriteStringToFile(JsonUtility.ToJson(this, true), PATH_CONFIG_FILE);
+            return this;
+        }
+
+        private void OnUpgrade(string oldVersionString)
+        {
+            Version newVersion = new Version(VERSION);
+            Version oldVersion = new Version(oldVersionString);
+
+            //Upgrade locking valuesd from Animated property to tags
+            if (newVersion >= "2.11.0" && oldVersion > "2.0" && oldVersion < "2.11.0")
+            {
+                ShaderOptimizer.UpgradeAnimatedPropertiesToTagsOnAllMaterials();
+            }
+        }
+    }
+
+    public class Version
+    {
+        private string value;
+
+        public Version(string s)
+        {
+            if (string.IsNullOrEmpty(s)) s = "0";
+            this.value = s;
+        }
+
+        public static bool operator ==(Version x, Version y)
+        {
+            return Helper.CompareVersions(x.value, y.value) == 0;
+        }
+
+        public static bool operator !=(Version x, Version y)
+        {
+            return Helper.CompareVersions(x.value, y.value) != 0;
+        }
+
+        public static bool operator >(Version x, Version y)
+        {
+            return Helper.CompareVersions(x.value, y.value) == -1;
+        }
+
+        public static bool operator <(Version x, Version y)
+        {
+            return Helper.CompareVersions(x.value, y.value) == 1;
+        }
+
+        public static bool operator >=(Version x, Version y)
+        {
+            return Helper.CompareVersions(x.value, y.value) < 1;
+        }
+
+        public static bool operator <=(Version x, Version y)
+        {
+            return Helper.CompareVersions(x.value, y.value) > -1;
+        }
+
+        public static bool operator ==(Version x, string y)
+        {
+            return Helper.CompareVersions(x.value, y) == 0;
+        }
+
+        public static bool operator !=(Version x, string y)
+        {
+            return Helper.CompareVersions(x.value, y) != 0;
+        }
+
+        public static bool operator >(Version x, string y)
+        {
+            return Helper.CompareVersions(x.value, y) == -1;
+        }
+
+        public static bool operator <(Version x, string y)
+        {
+            return Helper.CompareVersions(x.value, y) == 1;
+        }
+
+        public static bool operator >=(Version x, string y)
+        {
+            return Helper.CompareVersions(x.value, y) < 1;
+        }
+
+        public static bool operator <=(Version x, string y)
+        {
+            return Helper.CompareVersions(x.value, y) > -1;
+        }
+
+        public override bool Equals(object o)
+        {
+            if (o is Version) return this == (o as Version);
+            if (o is string) return this == (o as string);
+            return false;
+        }
+
+        public override string ToString()
+        {
+            return value;
+        }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+    }
+}