IEnumerator Start()
{
HarmonyAnimation[] animations = FindObjectsOfType <HarmonyAnimation>();
// Wait for audio to be complete before playing animation.
foreach (HarmonyAnimation animation in animations)
{
GameObject gameObject = animation.gameObject;
HarmonyRenderer renderer = gameObject.GetComponent <HarmonyRenderer>();
if (renderer != null)
{
// Preemptively load clip.
renderer.LoadClipIndex(0 /* first clip */);
}
// Wait for audio if necessary.
HarmonyAudio audio = gameObject.GetComponent <HarmonyAudio>();
if (audio != null)
{
yield return(StartCoroutine(audio.WaitForDownloads()));
}
}
foreach (HarmonyAnimation animation in animations)
{
animation.LoopAnimation(24.0f, 0 /* first clip */);
// Loop only part of the animation.
//animation.LoopFrames( 24.0f, 1.0f, 30.0f );
}
}
public IEnumerator RefreshRendererObject()
{
if (rendererObject == null)
{
yield break;
}
SceneSettings settings = FindObjectOfType(typeof(SceneSettings)) as SceneSettings;
if (settings == null)
{
yield break;
}
HarmonyRenderer renderer = rendererObject.GetComponent <HarmonyRenderer>();
HarmonyAnimation animation = rendererObject.GetComponent <HarmonyAnimation>();
HarmonyAudio audio = rendererObject.GetComponent <HarmonyAudio>();
if ((renderer == null) || (animation == null) || (audio == null))
{
yield break;
}
renderer.LoadClipIndex(settings.clipIdx);
// Make sure sound is all downloaded before playing animation.
yield return(StartCoroutine(audio.WaitForDownloads()));
// Loop animation indefinitely.
animation.ResetAnimation();
animation.LoopAnimation(frameRate, settings.clipIdx);
animation.ResumeAnimation(); // resume if paused.
}
private void OnTransformParentChanged()
{
// Update HarmonyRenderer component if prop has been reparented
// in a new hierarchy.
Transform parentTransform = gameObject.transform.parent;
if (parentTransform != cachedParentTransform)
{
cachedParentTransform = parentTransform;
HarmonyRenderer harmonyRenderer = GetComponentInParent <HarmonyRenderer>();
if (harmonyRenderer != cachedHarmonyRenderer)
{
if (cachedHarmonyRenderer != null)
{
cachedHarmonyRenderer.InvalidateProps();
}
cachedHarmonyRenderer = harmonyRenderer;
if (cachedHarmonyRenderer != null)
{
cachedHarmonyRenderer.InvalidateProps();
}
}
}
}
IEnumerator Start()
{
// Preemptively load clips.
HarmonyRenderer renderer = GetComponent <HarmonyRenderer>();
if ((renderer == null) || (renderer.clipNames == null))
{
yield break;
}
//yield return StartCoroutine(renderer.WaitForDownloads());
foreach (string clipName in renderer.clipNames)
{
renderer.LoadClipName(clipName);
}
// Wait for audio if necessary.
HarmonyAudio audio = GetComponent <HarmonyAudio>();
if (audio != null)
{
yield return(StartCoroutine(audio.WaitForDownloads()));
}
}
public static void CreateOrUpdateGenericMetadata(GameObject rootObject)
{
HarmonyRenderer renderer = rootObject.GetComponent <HarmonyRenderer>();
if (renderer == null)
{
return;
}
string projectFolder = renderer.projectFolder;
if (!new DirectoryInfo(projectFolder).Exists)
{
projectFolder = Application.streamingAssetsPath + "/" + projectFolder;
}
// Load custom metadata from XML
XML_Types.XML_GenericMeta[] xmlMetas = XML_StageLoader.loadGenericMeta(projectFolder).ToArray();
if (xmlMetas.Length > 0)
{
foreach (XML_Types.XML_GenericMeta xmlMeta in xmlMetas)
{
HarmonyMeta.MetaEntry entry = new HarmonyMeta.MetaEntry();
entry.metaName = xmlMeta._name;
entry.nodeName = xmlMeta._nodeName;
entry.metaValue = xmlMeta._value;
if (Array.Exists(renderer.clipNames, clipName => clipName == xmlMeta._clipName))
{
if (!renderer.metadata.ContainsKey(xmlMeta._clipName))
{
renderer.metadata[xmlMeta._clipName] = new HarmonyMeta();
}
if (renderer.metadata[xmlMeta._clipName].GetMeta(entry.metaName, entry.nodeName) == null)
{
renderer.metadata[xmlMeta._clipName].AddMeta(entry);
}
}
else
{
HarmonyProp[] propComponents = rootObject.GetComponentsInChildren <HarmonyProp>();
foreach (HarmonyProp propComponent in propComponents)
{
if (propComponent.playName == xmlMeta._playName)
{
if (propComponent.metadata.GetMeta(entry.metaName, entry.nodeName) == null)
{
propComponent.metadata.AddMeta(entry);
}
break;
}
}
}
}
}
}
private void PlayStaticFramePriv(float staticFrame, int clipIdx, float duration, CallbackEvents callbacks)
{
HarmonyRenderer renderer = GetComponent <HarmonyRenderer>();
if (renderer != null && renderer.clipNames != null)
{
if (clipIdx < renderer.clipNames.Length)
{
string clipName = renderer.clipNames[clipIdx];
PlayStaticFramePriv(staticFrame, clipName, duration, callbacks);
}
}
}
private void PlayAnimationPriv(float frameRate, int clipIdx, float startFrame, float duration, int nTimes, bool reverse, CallbackEvents callbacks)
{
HarmonyRenderer renderer = GetComponent <HarmonyRenderer>();
if (renderer != null && renderer.clipNames != null)
{
if (clipIdx < renderer.clipNames.Length)
{
string clipName = renderer.clipNames[clipIdx];
PlayAnimationPriv(frameRate, clipName, startFrame, duration, nTimes, reverse, callbacks);
}
}
}
private void PlayStaticFramePriv(float staticFrame, string clipName, float duration, CallbackEvents callbacks)
{
HarmonyRenderer renderer = GetComponent <HarmonyRenderer>();
if (renderer != null)
{
// Load clip at index if not already loaded.
renderer.LoadClipName(clipName);
}
if (duration < 0.0f)
{
AnimationClip clip = new AnimationClip(gameObject, 0.0f, clipName, staticFrame, 1.0f /*don't care*/, -1, false /*forward*/, callbacks);
PlayPriv(clip);
}
else
{
AnimationClip clip = new AnimationClip(gameObject, 0.0f, clipName, staticFrame, duration, 1, false /*forward*/, callbacks);
PlayPriv(clip);
}
}
IEnumerator Start()
{
SceneSettings settings = FindObjectOfType(typeof(SceneSettings)) as SceneSettings;
if (settings != null)
{
if (settings.clipNames.Length > 0)
{
rendererObject = new GameObject("RendererObject");
rendererObject.transform.parent = settings.viewerGroup.transform;
HarmonyRenderer renderer = rendererObject.AddComponent <HarmonyRenderer>();
HarmonyAnimation animation = rendererObject.AddComponent <HarmonyAnimation>();
HarmonyAudio audio = rendererObject.AddComponent <HarmonyAudio>();
AudioSource templateAudioSource = rendererObject.AddComponent <AudioSource>();
// Linear rolloff. Easier for sound to be heard.
templateAudioSource.rolloffMode = AudioRolloffMode.Linear;
// Set up clip collection in renderer.
renderer.projectFolder = settings.projectFolder;
renderer.clipNames = settings.clipNames;
renderer.LoadClipIndex(settings.clipIdx);
// Adjust renderer object size to fit in camera.
Bounds box = renderer.CalculateCurrentBoundingBox();
float scaleFactor = 5.0f / Mathf.Max(box.size.x, box.size.y);
rendererObject.transform.localScale = new Vector3(scaleFactor, scaleFactor, 1.0f);
// Make sure sound is all downloaded before playing animation.
yield return(StartCoroutine(audio.WaitForDownloads()));
// Loop animation indefinitely.
animation.ResetAnimation();
animation.LoopAnimation(frameRate, settings.clipIdx);
}
}
}
private void OnTransformParentChanged()
{
// Update HarmonyRenderer component if prop has been reparented
// in a new hierarchy.
Transform parentTransform = gameObject.transform.parent;
if (parentTransform != cachedParentTransform)
{
cachedParentTransform = parentTransform;
HarmonyRenderer harmonyRenderer = GetComponentInParent<HarmonyRenderer>();
if (harmonyRenderer != cachedHarmonyRenderer)
{
if (cachedHarmonyRenderer != null)
cachedHarmonyRenderer.InvalidateProps();
cachedHarmonyRenderer = harmonyRenderer;
if (cachedHarmonyRenderer != null)
cachedHarmonyRenderer.InvalidateProps();
}
}
}
void CreateCharacterAt(Vector3 pos)
{
//Message.Log( "Create Character at: " + pos );
#if CLONE_ON_TOUCH
GameObject rendererObject = GameObject.Instantiate(gameObjectToClone) as GameObject;
rendererObject.transform.localPosition = new Vector3(pos.x, pos.y, pos.z);
rendererObject.transform.parent = gameObject.transform;
HarmonyRenderer renderer = rendererObject.GetComponent <HarmonyRenderer>();
HarmonyAnimation animation = rendererObject.GetComponent <HarmonyAnimation>();
#else
GameObject rendererObject = new GameObject("Space Duck");
rendererObject.transform.localScale = new Vector3(0.01f, 0.01f, 0.01f);
rendererObject.transform.localPosition = new Vector3(pos.x, pos.y, pos.z);
rendererObject.transform.parent = gameObject.transform;
HarmonyRenderer renderer = rendererObject.AddComponent <HarmonyRenderer>();
HarmonyAnimation animation = rendererObject.AddComponent <HarmonyAnimation>();
Rigidbody2D rigidBody = rendererObject.AddComponent <Rigidbody2D>();
PolygonCollider2D collider = rendererObject.AddComponent <PolygonCollider2D>();
// Set up clip collection in renderer.
renderer.projectFolder = liveProjectFolder;
renderer.clipNames = XML_StageLoader.loadStageClipNames(renderer.projectFolder).ToArray();
renderer.syncCollider = HarmonyRenderer.SyncCollider.eAlways;
renderer.colliderShape = colliderShape;
#endif // CLONE_ON_TOUCH
// Randomly play a clip.
if (renderer.clipNames.Length > 0)
{
animation.LoopAnimation(24.0f, rand.Next() % renderer.clipNames.Length);
}
}
private void PlayAnimationPriv(float frameRate, string clipName, float startFrame, float duration, int nTimes, bool reverse, CallbackEvents callbacks)
{
HarmonyRenderer renderer = GetComponent <HarmonyRenderer>();
if (renderer != null)
{
// Load clip at index if not already loaded.
renderer.LoadClipName(clipName);
// Negative duration, replace with clip full duration.
if (duration < 0.0f)
{
float nFrames = renderer.GetClipFrameCount(clipName);
duration = (frameRate > 0.0f) ? ((nFrames + 1.0f - startFrame) / frameRate) : 0.0f;
}
}
if (duration > 0.0f)
{
AnimationClip clip = new AnimationClip(gameObject, frameRate, clipName, startFrame, duration, nTimes, reverse, callbacks);
PlayPriv(clip);
}
}
void postStart()
{
HarmonyRenderer renderer = GetComponent <HarmonyRenderer>();
// Preemptively load clip.
renderer.LoadClipIndex(0 /* first clip */);
HarmonyAnimation animation = gameObject.GetComponent <HarmonyAnimation>();
if (animation != null)
{
HarmonyAnimation.CallbackEvents callbacks = new HarmonyAnimation.CallbackEvents();
// Trigger a callback at frame 10 of animation.
callbacks.AddCallbackAtFrame(10.0f, CallbackMethod1);
// Trigget a callback at end of animation.
callbacks.AddCallbackAtEnd(CallbackMethod2);
// Loop animation indefinitely.
animation.LoopAnimation(frameRate, 0 /* first clip */, 1.0f /*first frame*/, false /*forward*/, callbacks);
}
renderer.readyToRender = true;
}
IEnumerator Start()
{
// Preemptively load clips.
HarmonyRenderer renderer = GetComponent <HarmonyRenderer>();
if ((renderer == null) || (renderer.clipNames == null))
{
yield break;
}
#if UNITY_WEBGL && !UNITY_EDITOR
if (WebGL_FileSystem.GetPreparationStateOfResource(renderer.projectFolder) != 3)
{
renderer.readyToRender = false;
PrepareProjectFolder(renderer.projectFolder);
}
else
{
postStart();
}
#else
postStart();
#endif
}
void Update()
{
HarmonyAudio audio = GetComponent <HarmonyAudio>();
if ((audio != null) && !audio.isReady)
{
return;
}
HarmonyAnimation animation = GetComponent <HarmonyAnimation>();
if (animation == null)
{
return;
}
HarmonyRenderer renderer = GetComponent <HarmonyRenderer>();
if ((renderer == null) || (renderer.clipNames == null))
{
return;
}
//if ( !renderer.isReady )
// return;
// Almost at end of our scheduled list, reschedule a new sequence.
if (renderer.clipNames.Length > animation.scheduledCount)
{
// Play all clips
foreach (string clipName in renderer.clipNames)
{
animation.PlayAnimation(frameRate, clipName);
}
}
}
public static void CreateOrUpdateAnchorsFromMetadata(GameObject rootObject)
{
HarmonyRenderer renderer = rootObject.GetComponent <HarmonyRenderer>();
if (renderer == null)
{
return;
}
string projectFolder = renderer.projectFolder;
if (!new DirectoryInfo(projectFolder).Exists)
{
projectFolder = Application.streamingAssetsPath + "/" + projectFolder;
}
// Load anchors metadata from XML
XML_Types.XML_AnchorMeta[] xmlAnchors = XML_StageLoader.loadAnchorMeta(projectFolder).ToArray();
if (xmlAnchors.Length > 0)
{
string anchorObjectName = "Anchors";
GameObject anchorContainerObject = null;
Transform[] childTransforms = rootObject.GetComponentsInChildren <Transform>(true /*includeInactive*/);
foreach (Transform childTransform in childTransforms)
{
GameObject childObject = childTransform.gameObject;
// Direct child to root object
if (childObject.transform.parent == rootObject.transform)
{
// Object matching preset Anchors game object name.
if (childObject.name == anchorObjectName)
{
anchorContainerObject = childObject;
break;
}
}
}
HarmonyAnchor[] anchorComponents = rootObject.GetComponentsInChildren <HarmonyAnchor>(true /*includeInactive*/);
foreach (XML_Types.XML_AnchorMeta xmlAnchor in xmlAnchors)
{
if (!Array.Exists(anchorComponents, anchor => (anchor.playName == xmlAnchor._playName) && (anchor.nodeName == xmlAnchor._nodeName)))
{
if (anchorContainerObject == null)
{
// Create container game object from anchors child to renderer object.
anchorContainerObject = new GameObject(anchorObjectName);
anchorContainerObject.transform.parent = rootObject.transform;
}
GameObject anchorObject = new GameObject(xmlAnchor._nodeName);
anchorObject.transform.parent = anchorContainerObject.transform;
HarmonyAnchor anchorComponent = anchorObject.AddComponent <HarmonyAnchor>();
anchorComponent.playName = xmlAnchor._playName;
anchorComponent.nodeName = xmlAnchor._nodeName;
}
}
}
}
public static void CreateOrUpdatePropsFromMetadata(GameObject rootObject)
{
HarmonyRenderer renderer = rootObject.GetComponent <HarmonyRenderer>();
if (renderer == null)
{
return;
}
string projectFolder = renderer.projectFolder;
if (!new DirectoryInfo(projectFolder).Exists)
{
projectFolder = Application.streamingAssetsPath + "/" + projectFolder;
}
// Load props metadata from XML
XML_Types.XML_PropMeta[] xmlProps = XML_StageLoader.loadPropMeta(projectFolder).ToArray();
if (xmlProps.Length > 0)
{
string propObjectName = "Props";
GameObject propContainerObject = null;
Transform[] childTransforms = rootObject.GetComponentsInChildren <Transform>(true /*includeInactive*/);
foreach (Transform childTransform in childTransforms)
{
GameObject childObject = childTransform.gameObject;
// Direct child to root object
if (childObject.transform.parent == rootObject.transform)
{
// Object matching preset Props game object name.
if (childObject.name == propObjectName)
{
propContainerObject = childObject;
break;
}
}
}
HarmonyProp[] propComponents = rootObject.GetComponentsInChildren <HarmonyProp>(true /*includeInactive*/);
foreach (XML_Types.XML_PropMeta xmlProp in xmlProps)
{
if (!Array.Exists(propComponents, prop => (prop.clipName == xmlProp._clipName) && (prop.playName == xmlProp._playName)))
{
if (propContainerObject == null)
{
// Create container game object from props child to renderer object.
propContainerObject = new GameObject(propObjectName);
propContainerObject.transform.parent = rootObject.transform;
}
GameObject propObject = new GameObject(xmlProp._playName);
propObject.transform.parent = propContainerObject.transform;
HarmonyProp propComponent = propObject.AddComponent <HarmonyProp>();
propComponent.clipName = xmlProp._clipName;
propComponent.playName = xmlProp._playName;
}
}
}
}
private void Awake()
{
cachedParentTransform = gameObject.transform.parent;
cachedHarmonyRenderer = GetComponentInParent <HarmonyRenderer>();
}
static void RenderAnchorControls(Transform objectTransform, GizmoType gizmoType, bool selected)
{
GameObject gameObject = objectTransform.gameObject;
HarmonyAnchor harmonyAnchor = gameObject.GetComponent <HarmonyAnchor>();
if (harmonyAnchor == null)
{
return;
}
HarmonyRenderer harmonyRenderer = harmonyAnchor.GetComponentInParent <HarmonyRenderer>();
if (harmonyRenderer == null)
{
return;
}
string clipName = harmonyRenderer.currentClipName;
if (string.IsNullOrEmpty(clipName))
{
return;
}
string projectFolder = harmonyRenderer.currentProjectFolder;
if (string.IsNullOrEmpty(projectFolder))
{
return;
}
float[] position = new float[3];
float[] rotation = new float[3];
float[] scale = new float[3];
if (Internal.CalculateLocatorTransform(projectFolder, clipName, harmonyRenderer.currentFrame, harmonyAnchor.nodeName, position, rotation, scale))
{
Vector3 localPosition = new Vector3(position[0], position[1], position[2]);
Quaternion localQuaternion = Quaternion.Euler(rotation[0], rotation[1], rotation[2]);
Vector3 localScale = new Vector3(scale[0], scale[1], scale[2]);
Matrix4x4 localMatrix = Matrix4x4.TRS(localPosition, localQuaternion, localScale);
Vector3 globalPosition = localMatrix.MultiplyPoint(Vector3.zero);
Vector3 globalRightDirection = localMatrix.MultiplyVector(Vector3.right);
Vector3 globalUpDirection = localMatrix.MultiplyVector(Vector3.up);
if (gameObject.transform.parent != null)
{
globalPosition = gameObject.transform.parent.localToWorldMatrix.MultiplyPoint(globalPosition);
globalRightDirection = gameObject.transform.parent.localToWorldMatrix.MultiplyVector(globalRightDirection);
globalUpDirection = gameObject.transform.parent.localToWorldMatrix.MultiplyVector(globalUpDirection);
}
globalRightDirection.Normalize();
globalUpDirection.Normalize();
Quaternion axisQuaternion = Quaternion.FromToRotation(Vector3.forward, Vector3.right);
Quaternion globalRightQuaternion = Quaternion.FromToRotation(new Vector3(1, 0, 0), globalRightDirection);
float arrowLength = HandleUtility.GetHandleSize(globalPosition) * 0.5f;
float axisLength = arrowLength * 0.6f;
float circleRadius = arrowLength * 0.5f;
Handles.color = selected ? Color.cyan : Color.red;
Handles.DrawWireDisc(globalPosition,
Vector3.forward,
circleRadius);
Handles.DrawLine(globalPosition - globalRightDirection * axisLength,
globalPosition);
Handles.DrawLine(globalPosition - globalUpDirection * axisLength,
globalPosition + globalUpDirection * axisLength);
Handles.ArrowCap(0,
globalPosition,
globalRightQuaternion * axisQuaternion,
arrowLength);
}
}
public override void OnInspectorGUI()
{
Object[] targetObjects = serializedObject.targetObjects;
EditorGUILayout.PropertyField(targetProjectFolder, new GUIContent("Project Folder"));
EditorGUILayout.PropertyField(targetClipNames, new GUIContent("Clip Names"), true);
EditorGUILayout.PropertyField(targetSheetResolution, new GUIContent("Sheet Resolution"));
EditorGUILayout.PropertyField(targetColor, new GUIContent("Color"));
EditorGUILayout.PropertyField(targetDepth, new GUIContent("Depth"));
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("Discretization Step");
targetDiscretizationStep.intValue = (int)EditorGUILayout.Slider(targetDiscretizationStep.intValue, 1, 30);
EditorGUILayout.EndHorizontal();
foldRenderTarget = EditorGUILayout.Foldout(foldRenderTarget, "Render Target");
if (foldRenderTarget)
{
++EditorGUI.indentLevel;
int valueIndex1 = targetRenderTarget.enumValueIndex;
bool isSameValue1 = !targetRenderTarget.hasMultipleDifferentValues;
EditorGUILayout.PropertyField(targetRenderTarget, new GUIContent("Target"));
int valueIndex2 = targetRenderTarget.enumValueIndex;
bool isSameValue2 = !targetRenderTarget.hasMultipleDifferentValues;
if ((valueIndex1 != valueIndex2) ||
!isSameValue1 && isSameValue2)
{
if (valueIndex2 == (int)HarmonyRenderer.RenderTarget.eScreen)
{
foreach (HarmonyRenderer harmonyRenderer in targetObjects)
{
GameObject rendererObject = harmonyRenderer.gameObject;
GenerateHarmonyMesh.ClearTextureObjectMesh(rendererObject);
}
// Components were removed from ui. Bail out now.
serializedObject.ApplyModifiedProperties();
EditorGUIUtility.ExitGUI();
}
else if (valueIndex2 == (int)HarmonyRenderer.RenderTarget.eRenderTexture)
{
foreach (HarmonyRenderer harmonyRenderer in targetObjects)
{
GameObject rendererObject = harmonyRenderer.gameObject;
GenerateHarmonyMesh.CreateOrUpdateTextureObjectMesh(rendererObject, true);
}
// Components were removed from ui. Bail out now.
serializedObject.ApplyModifiedProperties();
EditorGUIUtility.ExitGUI();
}
}
GUI.enabled = (targetRenderTarget.enumValueIndex == (int)HarmonyRenderer.RenderTarget.eRenderTexture);
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("Texture Resolution");
bool disabled = true;
if (targetObjects.Length == 1)
{
HarmonyRenderer harmonyRenderer = targetObjects[0] as HarmonyRenderer;
GameObject rendererObject = harmonyRenderer.gameObject;
MeshFilter meshFilter = harmonyRenderer.gameObject.GetComponent <MeshFilter>();
if ((meshFilter != null) && (meshFilter.sharedMesh != null))
{
Bounds bounds = meshFilter.sharedMesh.bounds;
float meshResolution = Mathf.Max(bounds.size.x, bounds.size.y);
if (meshResolution > 0.0f)
{
float currentTextureScale = targetRenderTextureScale.floatValue;
float currentResolution = meshResolution * currentTextureScale;
float newResolution = EditorGUILayout.Slider(currentResolution, 32, 8192);
if (newResolution != currentResolution)
{
float newTextureScale = newResolution / meshResolution;
harmonyRenderer.renderTextureScale = newTextureScale;
GenerateHarmonyMesh.CreateOrUpdateTextureObjectMesh(rendererObject);
serializedObject.Update();
}
disabled = false;
}
}
}
if (disabled)
{
bool wasEnabled = GUI.enabled;
GUI.enabled = false;
EditorGUILayout.Slider(32, 32, 8192);
GUI.enabled = wasEnabled;
}
EditorGUILayout.EndHorizontal();
//EditorGUILayout.PropertyField(targetRenderTextureViewport, new GUIContent("Texture Viewport"));
//EditorGUILayout.PropertyField(targetRenderTextureScale, new GUIContent("Texture Scale"));
if (!Application.isPlaying)
{
// Regenerate Mesh
EditorGUILayout.BeginHorizontal();
GUILayout.Space(EditorGUI.indentLevel * TAB_SIZE);
if (GUILayout.Button("Generate Mesh", GUILayout.Width(120)))
{
foreach (HarmonyRenderer harmonyRenderer in targetObjects)
{
GameObject rendererObject = harmonyRenderer.gameObject;
GenerateHarmonyMesh.CreateOrUpdateTextureObjectMesh(rendererObject, true);
}
}
if (GUILayout.Button("Clear Mesh", GUILayout.Width(120)))
{
foreach (HarmonyRenderer harmonyRenderer in targetObjects)
{
GameObject rendererObject = harmonyRenderer.gameObject;
GenerateHarmonyMesh.ClearTextureObjectMesh(rendererObject);
}
// Components were removed from ui. Bail out now.
EditorGUIUtility.ExitGUI();
}
EditorGUILayout.EndHorizontal();
}
}
GUI.enabled = true;
--EditorGUI.indentLevel;
}
foldColliders = EditorGUILayout.Foldout(foldColliders, "Colliders");
if (foldColliders)
{
++EditorGUI.indentLevel;
EditorGUILayout.PropertyField(targetSyncCollider, new GUIContent("Sync Collider"));
EditorGUILayout.PropertyField(targetColliderShape, new GUIContent("Collider Shape"));
EditorGUILayout.PropertyField(targetColliderTrigger, new GUIContent("Collider Trigger"));
if (!Application.isPlaying)
{
// Update colliders
EditorGUILayout.BeginHorizontal();
GUILayout.Space(EditorGUI.indentLevel * TAB_SIZE);
if (GUILayout.Button("Generate Colliders", GUILayout.Width(120)))
{
foreach (HarmonyRenderer harmonyRenderer in targetObjects)
{
harmonyRenderer.PreCalculateColliders();
}
// Components were removed from ui. Bail out now.
EditorGUIUtility.ExitGUI();
}
if (GUILayout.Button("Clear Colliders", GUILayout.Width(120)))
{
foreach (HarmonyRenderer harmonyRenderer in targetObjects)
{
harmonyRenderer.ClearColliders();
}
// Components were removed from ui. Bail out now.
EditorGUIUtility.ExitGUI();
}
EditorGUILayout.EndHorizontal();
}
--EditorGUI.indentLevel;
}
foldMetadata = EditorGUILayout.Foldout(foldMetadata, "Metadata");
if (foldMetadata)
{
++EditorGUI.indentLevel;
// Override label width to 1 pixel...
EditorGUIUtility.labelWidth = 1f;
for (int i = 0; i < System.Math.Min(targetMetadataKeys.arraySize, targetMetadataLists.arraySize); ++i)
{
SerializedProperty targetMetadataKey = targetMetadataKeys.GetArrayElementAtIndex(i);
SerializedProperty targetMetadataContainer = targetMetadataLists.GetArrayElementAtIndex(i);
SerializedProperty targetMetadataList = targetMetadataContainer.FindPropertyRelative("metas");
EditorGUILayout.LabelField(targetMetadataKey.stringValue);
EditorGUILayout.BeginHorizontal();
GUILayout.Space(EditorGUI.indentLevel * TAB_SIZE);
EditorGUILayout.BeginVertical();
EditorGUILayout.BeginHorizontal("box");
GUILayout.Label("name ");
GUILayout.Label("node");
GUILayout.Label("value");
if (GUILayout.Button("+", GUILayout.Width(16), GUILayout.Height(16)))
{
++targetMetadataList.arraySize;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Space(EditorGUI.indentLevel * TAB_SIZE);
EditorGUILayout.BeginVertical();
for (int j = 0; j < targetMetadataList.arraySize; ++j)
{
SerializedProperty targetMetadata = targetMetadataList.GetArrayElementAtIndex(j);
EditorGUILayout.BeginHorizontal("box");
SerializedProperty targetMetadataName = targetMetadata.FindPropertyRelative("metaName");
SerializedProperty targetMetadataNodeName = targetMetadata.FindPropertyRelative("nodeName");
SerializedProperty targetMetadataValue = targetMetadata.FindPropertyRelative("metaValue");
EditorGUILayout.PropertyField(targetMetadataName, new GUIContent(" "));
EditorGUILayout.PropertyField(targetMetadataNodeName, new GUIContent(" "));
EditorGUILayout.PropertyField(targetMetadataValue, new GUIContent(" "));
if (GUILayout.Button("-", GUILayout.Width(16), GUILayout.Height(16)))
{
targetMetadataList.DeleteArrayElementAtIndex(j);
}
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.EndVertical();
EditorGUILayout.EndHorizontal();
}
if (!Application.isPlaying)
{
// Update props and anchors
EditorGUILayout.BeginHorizontal();
GUILayout.Space(EditorGUI.indentLevel * TAB_SIZE);
if (GUILayout.Button("Update All Metadata", GUILayout.Width(120)))
{
foreach (HarmonyRenderer harmonyRenderer in targetObjects)
{
GameObject rendererObject = harmonyRenderer.gameObject;
// Create Metadata.
GenerateHarmonyMeta.CreateOrUpdatePropsFromMetadata(rendererObject);
GenerateHarmonyMeta.CreateOrUpdateAnchorsFromMetadata(rendererObject);
GenerateHarmonyMeta.CreateOrUpdateGenericMetadata(rendererObject);
}
serializedObject.Update();
}
EditorGUILayout.EndHorizontal();
}
--EditorGUI.indentLevel;
// Restore label width...
EditorGUIUtility.labelWidth = 0f;
}
serializedObject.ApplyModifiedProperties();
if (GUI.changed)
{
foreach (Object target in targetObjects)
{
EditorUtility.SetDirty(target);
}
}
}
private void Awake()
{
harmonyRenderer = GetComponentInParent <HarmonyRenderer>();
}
public static void CreateOrUpdateTextureObjectMesh(GameObject rootObject, bool regenerateMesh = false)
{
HarmonyRenderer renderer = rootObject.GetComponent <HarmonyRenderer>();
if (renderer == null)
{
return;
}
//if (renderer.renderTarget != HarmonyRenderer.RenderTarget.eRenderTexture)
// return;
MeshFilter meshFilter = rootObject.GetComponent <MeshFilter>();
if (meshFilter == null)
{
meshFilter = rootObject.AddComponent <MeshFilter>();
}
MeshRenderer meshRenderer = rootObject.GetComponent <MeshRenderer>();
if (meshRenderer == null)
{
meshRenderer = rootObject.AddComponent <MeshRenderer>();
}
Bounds box = new Bounds(Vector3.zero, Vector3.zero);
if ((meshFilter.sharedMesh == null) || regenerateMesh)
{
box = renderer.CalculateCumulativeBoundingBox();
}
else
{
box = meshFilter.sharedMesh.bounds;
}
if (box.size.sqrMagnitude > 0.0f)
{
float textureScale = renderer.renderTextureScale;
float textureWidth = Mathf.NextPowerOfTwo((int)(box.size.x * textureScale));
float textureHeight = Mathf.NextPowerOfTwo((int)(box.size.y * textureScale));
float textureX = box.min.x * textureScale;
float textureY = box.min.y * textureScale;
float x = box.min.x;
float y = box.min.y;
float width = box.size.x;
float height = box.size.y;
float scaledWidth = width * textureScale;
float scaledHeight = height * textureScale;
float u0 = 0.0f;
float u1 = scaledWidth / textureWidth;
float v0 = 1.0f - (scaledHeight / textureHeight);
float v1 = 1.0f;
//Message.Log( "uvs: (" + u0 + "," + v0 + ") (" + u1 + "," + v1 + ")" );
renderer.renderTextureViewport = new Rect(textureX, textureY, textureWidth, textureHeight);
// Create basic quad to map texture unto.
if ((meshFilter.sharedMesh == null) || regenerateMesh)
{
Mesh mesh = new Mesh();
mesh.name = rootObject.name + "_mesh";
Vector3[] vertices = new Vector3[4]
{
new Vector3(x, y, 0),
new Vector3(x + width, y, 0),
new Vector3(x + width, y + height, 0),
new Vector3(x, y + height, 0)
};
Vector3[] normals = new Vector3[4]
{
new Vector3(0, 0, -1.0f),
new Vector3(0, 0, -1.0f),
new Vector3(0, 0, -1.0f),
new Vector3(0, 0, -1.0f)
};
Vector2[] uvs = new Vector2[4]
{
new Vector2(u0, v1),
new Vector2(u1, v1),
new Vector2(u1, v0),
new Vector2(u0, v0)
};
int[] faces = new int[6]
{
2, 1, 0,
3, 2, 0
};
mesh.vertices = vertices;
mesh.normals = normals;
mesh.uv = uvs;
mesh.triangles = faces;
UnityEngine.Object.DestroyImmediate(meshFilter.sharedMesh);
meshFilter.mesh = mesh;
}
else
{
Mesh meshCopy = Mesh.Instantiate(meshFilter.sharedMesh) as Mesh;
meshCopy.name = rootObject.name + "_mesh";
Vector2[] uvs = new Vector2[4]
{
new Vector2(u0, v1),
new Vector2(u1, v1),
new Vector2(u1, v0),
new Vector2(u0, v0)
};
meshCopy.uv = uvs;
UnityEngine.Object.DestroyImmediate(meshFilter.sharedMesh);
meshFilter.mesh = meshCopy;
}
// Create material for new mesh.
if (meshRenderer.sharedMaterial == null)
{
Shader shader = Shader.Find("Harmony/UnlitTransparentPremult");
if (shader != null)
{
Material mat = new Material(shader);
mat.name = rootObject.name + "_mat";
UnityEngine.Object.DestroyImmediate(meshRenderer.sharedMaterial);
meshRenderer.material = mat;
}
}
}
}
private void Awake()
{
cachedParentTransform = gameObject.transform.parent;
cachedHarmonyRenderer = GetComponentInParent<HarmonyRenderer>();
}
static void Run()
{
projectFolder = EditorUtility.OpenFolderPanel("Import Harmony Game Engine Project", projectFolder, "");
if (!string.IsNullOrEmpty(projectFolder) &&
new DirectoryInfo(projectFolder).Exists)
{
string[] clipNames = XML_StageLoader.loadStageClipNames(projectFolder).ToArray();
if (clipNames.Length > 0)
{
string name = Path.GetFileName(projectFolder);
GameObject rendererObject = new GameObject(name);
HarmonyRenderer renderer = rendererObject.AddComponent <HarmonyRenderer>();
/*HarmonyAnimation animation = */ rendererObject.AddComponent <HarmonyAnimation>();
// Do not create audio components if there is no audio sequences in specified project folder...
bool needAudio = false;
foreach (string clipName in clipNames)
{
List <XML_Types.XML_SoundSequence> soundSequences = XML_StageLoader.loadSoundSequences(projectFolder, clipName);
if (soundSequences.Count > 0)
{
needAudio = true;
break;
}
}
if (needAudio)
{
/*HarmonyAudio audio = */ rendererObject.AddComponent <HarmonyAudio>();
/*AudioSource audioSource = */ rendererObject.AddComponent <AudioSource>();
}
// Remove streaming assets path part of the specified project folder if
// applicable. An absolute path will work on the user's machine but will
// likely not be found elsewhere.
string streamingAssetsPath = Application.streamingAssetsPath;
string rendererProjectFolder = projectFolder;
if (rendererProjectFolder.Contains(streamingAssetsPath))
{
rendererProjectFolder = rendererProjectFolder.Substring(streamingAssetsPath.Length + 1);
}
renderer.projectFolder = rendererProjectFolder;
renderer.clipNames = clipNames;
renderer.renderTarget = HarmonyRenderer.RenderTarget.eRenderTexture;
// Create Mesh.
GenerateHarmonyMesh.CreateOrUpdateTextureObjectMesh(rendererObject);
// Adjust texture scale factor if resolution is too small...
MeshFilter meshFilter = rendererObject.GetComponent <MeshFilter>();
if (meshFilter != null)
{
if (meshFilter.sharedMesh != null)
{
Bounds bounds = meshFilter.sharedMesh.bounds;
float meshResolution = Mathf.Max(bounds.size.x, bounds.size.y);
if (meshResolution < 1024.0f)
{
// Adjust texture scale.
float newTextureScale = 1024.0f / meshResolution;
renderer.renderTextureScale = newTextureScale;
// Update mesh with new texture scale values.
GenerateHarmonyMesh.CreateOrUpdateTextureObjectMesh(rendererObject);
}
}
}
// Create Metadata.
GenerateHarmonyMeta.CreateOrUpdatePropsFromMetadata(rendererObject);
GenerateHarmonyMeta.CreateOrUpdateAnchorsFromMetadata(rendererObject);
GenerateHarmonyMeta.CreateOrUpdateGenericMetadata(rendererObject);
// If no Harmony cameras available, ask user if he wants to create one.
HarmonyCamera[] harmonyCameras = FindObjectsOfType <HarmonyCamera>();
if (harmonyCameras.Length == 0)
{
string title = "Create HarmonyCamera components?";
string body = "Only a camera with the HarmonyCamera component will render Harmony Game Objects.";
if (EditorUtility.DisplayDialog(title, body, "Create", "Do Not Create"))
{
// Make sure there is at least one camera in the scene.
Camera[] cameras = FindObjectsOfType <Camera>();
if (cameras.Length == 0)
{
GameObject cameraObject = new GameObject("Main Camera");
/*Camera camera = */ cameraObject.AddComponent <Camera>();
}
CreateHarmonyCamera.ShowWindow();
}
}
}
}
}
