Tanoda
CheckAction.cs
Go to the documentation of this file.
1using System;
2using System.Collections;
3using System.Globalization;
4using System.Runtime.Serialization;
5using GILES;
6using JetBrains.Annotations;
7using NaughtyAttributes;
8using UnityEngine;
9using UnityEngine.UI;
10
11public class CheckAction : ActionObject, ISerializable
12{
14 public string canvasSelectorName = "Canvas_selector";
15 public string selectedHash = "";
16 public float timeToWatch = 2.0f;
17 public InputField inputTime;
18
19 [SerializeField] private GameObject selectedGO;
20 private GameObject canvasSelector;
21 private bool active;
22 private Material[] mats;
23 private Material[] origMats;
24 private float _timeToWatch = 2.0f;
25 private Material highlightMat;
26 private GameObject highlightHolder;
27 protected SkinnedMeshRenderer[] highlightSkinnedRenderers;
28 protected SkinnedMeshRenderer[] existingSkinnedRenderers;
29 protected MeshRenderer[] highlightRenderers;
30 protected MeshRenderer[] existingRenderers;
31
32 public override void Start()
33 {
34 base.Start();
35 highlightMat = (Material) Resources.Load("SteamVR_HoverHighlightBlue", typeof(Material));
36 }
37
38 private bool IsWatching()
39 {
40 return GazePickupHelper.instance.target == selectedGO;
41 }
42
43 [Button]
44 protected virtual void CreateHighlightRenderers()
45 {
46 existingSkinnedRenderers = selectedGO.GetComponentsInChildren<SkinnedMeshRenderer>(true);
47 highlightHolder = new GameObject("Highlighter");
48 highlightSkinnedRenderers = new SkinnedMeshRenderer[existingSkinnedRenderers.Length];
49
50 for (var skinnedIndex = 0; skinnedIndex < existingSkinnedRenderers.Length; skinnedIndex++)
51 {
52 var existingSkinned = existingSkinnedRenderers[skinnedIndex];
53
54 var newSkinnedHolder = new GameObject("SkinnedHolder");
55 newSkinnedHolder.transform.parent = highlightHolder.transform;
56 var newSkinned = newSkinnedHolder.AddComponent<SkinnedMeshRenderer>();
57 var materials = new Material[existingSkinned.sharedMaterials.Length];
58 for (var materialIndex = 0; materialIndex < materials.Length; materialIndex++)
59 materials[materialIndex] = highlightMat;
60
61 newSkinned.sharedMaterials = materials;
62 newSkinned.sharedMesh = existingSkinned.sharedMesh;
63 newSkinned.rootBone = existingSkinned.rootBone;
64 newSkinned.updateWhenOffscreen = existingSkinned.updateWhenOffscreen;
65 newSkinned.bones = existingSkinned.bones;
66
67 highlightSkinnedRenderers[skinnedIndex] = newSkinned;
68 }
69
70 var existingFilters = selectedGO.GetComponentsInChildren<MeshFilter>(true);
71 existingRenderers = new MeshRenderer[existingFilters.Length];
72 highlightRenderers = new MeshRenderer[existingFilters.Length];
73
74 for (var filterIndex = 0; filterIndex < existingFilters.Length; filterIndex++)
75 {
76 var existingFilter = existingFilters[filterIndex];
77 var existingRenderer = existingFilter.GetComponent<MeshRenderer>();
78
79 if (existingFilter == null || existingRenderer == null)
80 continue;
81
82 var newFilterHolder = new GameObject("FilterHolder");
83 newFilterHolder.transform.parent = highlightHolder.transform;
84 var newFilter = newFilterHolder.AddComponent<MeshFilter>();
85 newFilter.sharedMesh = existingFilter.sharedMesh;
86 var newRenderer = newFilterHolder.AddComponent<MeshRenderer>();
87
88 var materials = new Material[existingRenderer.sharedMaterials.Length];
89 for (var materialIndex = 0; materialIndex < materials.Length; materialIndex++)
90 materials[materialIndex] = highlightMat;
91 newRenderer.sharedMaterials = materials;
92
93 highlightRenderers[filterIndex] = newRenderer;
94 existingRenderers[filterIndex] = existingRenderer;
95 }
96
98 }
99
100 protected virtual void UpdateHighlightRenderers()
101 {
102 if (highlightHolder == null)
103 return;
104
105 for (var skinnedIndex = 0; skinnedIndex < existingSkinnedRenderers.Length; skinnedIndex++)
106 {
107 var existingSkinned = existingSkinnedRenderers[skinnedIndex];
108 var highlightSkinned = highlightSkinnedRenderers[skinnedIndex];
109
110 if (existingSkinned != null && highlightSkinned != null)
111 {
112 highlightSkinned.transform.position = existingSkinned.transform.position;
113 highlightSkinned.transform.rotation = existingSkinned.transform.rotation;
114 highlightSkinned.transform.localScale = existingSkinned.transform.lossyScale;
115 highlightSkinned.localBounds = existingSkinned.localBounds;
116 var blendShapeCount = existingSkinned.sharedMesh.blendShapeCount;
117 for (var blendShapeIndex = 0; blendShapeIndex < blendShapeCount; blendShapeIndex++)
118 highlightSkinned.SetBlendShapeWeight(blendShapeIndex,
119 existingSkinned.GetBlendShapeWeight(blendShapeIndex));
120 }
121 }
122
123 for (var rendererIndex = 0; rendererIndex < highlightRenderers.Length; rendererIndex++)
124 {
125 var existingRenderer = existingRenderers[rendererIndex];
126 var highlightRenderer = highlightRenderers[rendererIndex];
127
128 if (existingRenderer != null && highlightRenderer != null)
129 {
130 highlightRenderer.transform.position = existingRenderer.transform.position;
131 highlightRenderer.transform.rotation = existingRenderer.transform.rotation;
132 highlightRenderer.transform.localScale = existingRenderer.transform.lossyScale;
133 }
134 }
135 }
136
137 private new void Update()
138 {
139 base.Update();
140
141 if (!active)
142 return;
143
144 if (!selectedGO) selectedGO = HashingManager.instance.GetGOFromHash(selectedHash);
146 if (IsWatching())
147 {
148 if (mats == null)
149 mats = selectedGO.GetComponentInChildren<MeshRenderer>().materials;
150
151 timeToWatch -= Time.deltaTime;
152
153
154 Macro.SetMaterialAlpha(mats, 0.25f + Mathf.Abs(0.75f - timeToWatch / (_timeToWatch / 0.75f)));
155 if (timeToWatch <= 0)
156 {
157 selectedGO.GetComponentInChildren<MeshRenderer>().materials = origMats;
158 TriggerOutput(outPuts[0].name);
159 Destroy(highlightHolder);
160 active = false;
161 }
162 }
163 }
164
165
166 public void InputEnded(string input)
167 {
168 if (input == "")
169 {
170 timeToWatch = 0;
171 return;
172 }
173
174 var ci = CultureInfo.CurrentCulture;
175 var nfi = ci.NumberFormat;
176 input = input.Replace(',', nfi.CurrencyDecimalSeparator[0]);
177 input = input.Replace('.', nfi.CurrencyDecimalSeparator[0]);
178 inputTime.text = input;
179 if (input.Contains(":"))
180 {
181 var first = input.Split(':');
182 timeToWatch = int.Parse(first[0]) * 60;
183 timeToWatch += float.Parse(first[1]);
184 }
185 else
186 {
187 timeToWatch = float.Parse(input);
188 }
189
190 inputTime.text = (timeToWatch % 60).ToString("00.00").Replace(',', '.');
191 }
192
193 public override void Triggered(string id)
194 {
195 base.Triggered(id);
196 active = true;
197 _timeToWatch = timeToWatch;
198 try
199 {
200 if (!selectedGO)
201 selectedGO = HashingManager.instance.GetGOFromHash(selectedHash);
202
204 mats = selectedGO.GetComponentInChildren<MeshRenderer>().materials;
205 origMats = new Material[mats.Length];
206 Array.Copy(mats, origMats, mats.Length);
208 Macro.SetMaterialAlpha(mats, 0.25f);
209 }
210 catch (Exception e)
211 {
212 Debug.LogError(e);
213 }
214 }
215
216
217 public void SetGameObject(GameObject go)
218 {
219 if (go == null) return;
220 var reinit = gop.asset != null;
221 gop.asset = go;
222
223 if (!gop.enabled)
224 gop.enabled = true;
225
226 if (reinit)
228 else
229 gop.Initialize();
230 selectedGO = go;
231
232 GetComponentInChildren<ObjectDroppedEvent>().NameText.text = go.name;
233
234 //Triggered("");
235
236 //Controller.Instance.Trigger(GetOutputs()[0]);
237 }
238
239 public IEnumerator SetGameObjectJob(string hash)
240 {
241 if (selectedHash == "")
242 selectedHash = hash;
243
244 yield return new WaitForEndOfFrame();
245 while (LoadingManager.instance.isLoading) yield return new WaitForEndOfFrame();
246 SetGameObject(hash);
247 }
248
249 public void SetGameObject(string hash)
250 {
251 if (hash == "") return;
252 var reinit = gop.asset != null;
253 gop.asset = HashingManager.instance.GetGOFromHash(hash);
254 if (gop.asset == null) return;
255
256 if (!gop.enabled)
257 gop.enabled = true;
258
259 if (reinit)
261 else
262 gop.Initialize();
263 selectedGO = gop.asset;
264
265 GetComponentInChildren<ObjectDroppedEvent>().NameText.text = gop.asset.name;
266
267 //Triggered("");
268
269 //Controller.Instance.Trigger(GetOutputs()[0]);
270 }
271
272 public void SetSelectedGO()
273 {
275 canvasSelector.GetComponent<Canvas>().enabled = false;
276 GetComponentInParent<Canvas>().enabled = true;
277 canvasSelector.GetComponentInChildren<Button>().onClick.RemoveListener(SetSelectedGO);
278
280 }
281
282 public void TriggerSelection()
283 {
284 if (!canvasSelector)
285 canvasSelector = GameObject.Find(canvasSelectorName);
286
287 if (!canvasSelector)
288 {
289 Debug.LogError(canvasSelectorName + " not found!");
290 return;
291 }
292
293 GetComponentInParent<Canvas>().enabled = false;
294 canvasSelector.GetComponentInChildren<Button>().onClick.AddListener(SetSelectedGO);
295 canvasSelector.GetComponent<Canvas>().enabled = true;
296 pb_SelectionHandle.instance.SetTool(Tool.None);
297 }
298
299 [CanBeNull]
300 public GameObject GetGameObject()
301 {
302 if (selectedGO == null)
304
305 return selectedGO;
306 }
307
308 public new void GetObjectData(SerializationInfo info, StreamingContext context)
309 {
310 base.GetObjectData(info, context);
311 info.AddValue("selectedGO", selectedGO, typeof(GameObject));
312 info.AddValue("timeToWatch", timeToWatch, typeof(float));
313 try
314 {
315 info.AddValue("selectedGOHash", selectedGO.GetComponent<HashHolder>().Hash, typeof(string));
316 }
317 catch (Exception)
318 {
319 // ignored
320 }
321 }
322
323 public CheckAction(SerializationInfo info, StreamingContext context) : base(info, context)
324 {
325 selectedGO = (GameObject) info.GetValue("selectedGO", typeof(GameObject));
326
327 foreach (var e in info)
328 {
329 if (e.Name == "selectedGOHash")
330 {
331 selectedHash = info.GetString("selectedGOHash");
332 break;
333 }
334
335 if (e.Name == "timeToWatch") timeToWatch = info.GetSingle("timeToWatch");
336 }
337 }
338}
UnityEngine.UI.Button Button
Definition: Pointer.cs:7
UnityEngine.Debug Debug
Definition: TanodaServer.cs:19
void TriggerOutput(string id)
List< GameObject > outPuts
Definition: ActionObject.cs:19
IEnumerator SetGameObjectJob(string hash)
Definition: CheckAction.cs:239
override void Triggered(string id)
Definition: CheckAction.cs:193
SkinnedMeshRenderer[] highlightSkinnedRenderers
Definition: CheckAction.cs:27
void TriggerSelection()
Definition: CheckAction.cs:282
MeshRenderer[] existingRenderers
Definition: CheckAction.cs:30
float timeToWatch
Definition: CheckAction.cs:16
string canvasSelectorName
Definition: CheckAction.cs:14
void InputEnded(string input)
Definition: CheckAction.cs:166
SkinnedMeshRenderer[] existingSkinnedRenderers
Definition: CheckAction.cs:28
new void GetObjectData(SerializationInfo info, StreamingContext context)
Definition: CheckAction.cs:308
void SetSelectedGO()
Definition: CheckAction.cs:272
virtual void CreateHighlightRenderers()
Definition: CheckAction.cs:44
void SetGameObject(string hash)
Definition: CheckAction.cs:249
CheckAction(SerializationInfo info, StreamingContext context)
Definition: CheckAction.cs:323
GameObjectPreview gop
Definition: CheckAction.cs:13
InputField inputTime
Definition: CheckAction.cs:17
void SetGameObject(GameObject go)
Definition: CheckAction.cs:217
virtual void UpdateHighlightRenderers()
Definition: CheckAction.cs:100
MeshRenderer[] highlightRenderers
Definition: CheckAction.cs:29
GameObject GetGameObject()
Definition: CheckAction.cs:300
override void Start()
Definition: CheckAction.cs:32
string selectedHash
Definition: CheckAction.cs:15
static void Clear()
Definition: pb_Selection.cs:61
static GameObject activeGameObject
Definition: pb_Selection.cs:82
void Initialize(bool reinitialize=false)
static GazePickupHelper instance
string Hash
Definition: HashHolder.cs:18
Definition: Macro.cs:12
static void ChangeMaterialsModeToFadeMode(Material[] mats)
Definition: Macro.cs:276
static void SetMaterialAlpha(Material[] mats, float value)
Definition: Macro.cs:290
Tool
Definition: pb_Enum.cs:24