xi/Assets/VolumetricFog/Editor/VolumetricFogSInfo.cs

using UnityEngine;
using System.Text;
using System.Collections;
using System.Collections.Generic;

namespace VolumetricFogAndMist {
	public class VolumetricFogSInfo {

		public string name = "";
		public string path = "";
		public List<SCShaderPass> passes = new List<SCShaderPass>();
		public List<SCKeyword> keywords = new List<SCKeyword>();
		public bool pendingChanges;
		public bool editedByShaderControl;
		public int enabledKeywordCount;

		public void Add(SCShaderPass pass) {
			passes.Add(pass);
			UpdateKeywords();
		}

		public void EnableKeywords() {
			keywords.ForEach((SCKeyword keyword) => keyword.enabled = true);
		}

		void UpdateKeywords() {
			passes.ForEach((SCShaderPass pass) => {
					for (int l = 0; l < pass.keywordLines.Count; l++) {
						SCKeywordLine line = pass.keywordLines[l];
						for (int k = 0; k < line.keywords.Count; k++) {
							SCKeyword keyword = line.keywords[k];
							if (!keywords.Contains(keyword)) {
								if (SCKeywordChecker.IsValid(keyword.name)) {
									keywords.Add(keyword);
								}
							}
						}
					}
				});

			enabledKeywordCount = 0;
			keywords.ForEach((SCKeyword kw) => {
					if (kw.enabled)
						enabledKeywordCount++;
				});
		}

		public SCKeyword GetKeyword(string name) {
			int kCount = keywords.Count;
			for (int k = 0; k < kCount; k++) {
				SCKeyword keyword = keywords[k];
				if (keyword.name.Equals(name))
					return keyword;
			}
			return new SCKeyword(name);
		}

	}

	public class SCShaderPass {
		public int pass;
		public List<SCKeywordLine> keywordLines = new List<SCKeywordLine>();
		public int keywordCount;

		public void Add(SCKeywordLine keywordLine) {
			keywordLines.Add(keywordLine);
			UpdateKeywordCount();
		}

		public void Add(List<SCKeywordLine> keywordLines) {
			this.keywordLines.AddRange(keywordLines);
			UpdateKeywordCount();
		}

		void UpdateKeywordCount() {
			keywordCount = 0;
			keywordLines.ForEach((SCKeywordLine obj) => keywordCount += obj.keywordCount);
		}

		public void Clear() {
			keywordCount = 0;
			keywordLines.Clear();
		}
	}

	public class SCKeywordLine {
		public List<SCKeyword> keywords = new List<SCKeyword>();
		public bool hasUnderscoreVariant;

		public SCKeyword GetKeyword(string name) {
			int kc = keywords.Count;
			for (int k = 0; k < kc; k++) {
				SCKeyword keyword = keywords[k];
				if (keyword.name.Equals(name)) {
					return keyword;
				}
			}
			return null;
		}

		public void Add(SCKeyword keyword) {
			if (GetKeyword(keyword.name) != null)
				return;
			// ignore underscore keywords
			bool goodKeyword = false;
			for (int k = 0; k < keyword.name.Length; k++) {
				if (keyword.name[k] != '_') {
					goodKeyword = true;
					break;
				}
			}
			if (goodKeyword) {
				keywords.Add(keyword);
			} else {
				keyword.isUnderscoreKeyword = true;
				hasUnderscoreVariant = true;
			}
		}

		public void DisableKeywords() {
			keywords.ForEach((SCKeyword obj) => obj.enabled = false);
		}

		public void Clear() {
			keywords.Clear();
		}

		public int keywordCount {
			get { 
				return keywords.Count;
			}
		}

		public int keywordsEnabledCount {
			get {
				int kCount = keywords.Count;
				int enabledCount = 0;
				for (int k = 0; k < kCount; k++) {
					if (keywords[k].enabled)
						enabledCount++;
				}
				return enabledCount;
			}
		}

		public override string ToString() {
			StringBuilder sb = new StringBuilder();
			for (int k = 0; k < keywords.Count; k++) {
				if (k > 0)
					sb.Append(" ");
				sb.Append(keywords[k].name);
			}
			return sb.ToString();
		}

	}

	public class SCKeyword {
		public string name;
		public bool enabled;
		public bool isUnderscoreKeyword;

		public SCKeyword(string name) {
			this.name = name;
			enabled = true;
		}

		public override bool Equals(object obj) {
			if (obj is SCKeyword) {
				SCKeyword other = (SCKeyword)obj;
				return name.Equals(other.name);
			}
			return false;
		}

		public override int GetHashCode() {
			return name.GetHashCode();
		}

		public override string ToString() {
			return name;
		}
	}

	static class SCKeywordChecker {

		static Dictionary<string, string> dict = new Dictionary<string, string>();

		static SCKeywordChecker() {
			string[][] kw = new string[][]
			{
				new string[] { VolumetricFog.SKW_FOG_HAZE_ON, "Sky Haze" },
				new string[] { VolumetricFog.SKW_FOG_OF_WAR_ON, "Fog of War" },
				new string[] { VolumetricFog.SKW_LIGHT_SCATTERING, "Light Scattering" },
				new string[] { VolumetricFog.SKW_SUN_SHADOWS, "Sun Shadows" },
				new string[] { VolumetricFog.SKW_FOG_VOID_BOX, "Fog Void (Box shape)" },
				new string[]
				{
					VolumetricFog.SKW_FOG_VOID_SPHERE,
					"Fog Void (Sphere shape)"
				},
				new string[] { VolumetricFog.SKW_FOG_AREA_BOX, "Fog Area (Box shape)" },
				new string[]
				{
					VolumetricFog.SKW_FOG_AREA_SPHERE,
					"Fog Area (Sphere shape)"
				},
				new string[] { VolumetricFog.SKW_FOG_BLUR, "Depth Blur" }, 
				new string[] { VolumetricFog.SKW_FOG_USE_XY_PLANE, "Use XY Plane" },
				new string[]
				{
					VolumetricFog.SKW_FOG_COMPUTE_DEPTH,
					"Compute Depth"
				}
			};
			for (int k = 0; k < kw.Length; k++) dict[kw[k][0]] = kw[k][1];
		}

		public static bool IsValid(string name) {
			return dict.ContainsKey(name);
		}

		public static string Translate(string name) {
			if (dict.ContainsKey(name)) {
				return dict[name];
			} else {
				return name;
			}
		}


		
	}
	
	
}