public override bool Simulate(StoryboardData data, StoryboardNode currentNode, StoryboardNode nextNode, SimulationTargetData targetData)
{
Vector3 finalPosition = Vector3.zero;
Quaternion finalRotation = Quaternion.identity;
int counter = 0;
while (counter < data.m_implementationTimeout)
{
float distance = Random.Range(m_distanceLB, m_distanceUB);
float directionMultiplier = m_fixedDirection ? (m_isRight ? 1.0f : -1.0f) : ((Random.Range(0.0f, 1.0f) < 0.5f) ? -1.0f : 1.0f);
finalPosition = targetData.m_targetPosition + targetData.m_targetRight * directionMultiplier * distance;
finalRotation = Quaternion.LookRotation(targetData.m_targetPosition - finalPosition);
if (CheckVisibility(data, currentNode, finalPosition, finalRotation, targetData))
{
SetSimulationData(currentNode, finalPosition, finalRotation, data.m_defaultFOV);
return(true);
}
counter++;
}
SetSimulationData(currentNode, finalPosition, finalRotation, data.m_defaultFOV);
return(false);
}
public override bool Simulate(StoryboardData data, StoryboardNode currentNode, StoryboardNode nextNode, SimulationTargetData targetData)
{
Vector3 finalPosition = Vector3.zero;
Quaternion finalRotation = Quaternion.identity;
int counter = 0;
while (counter < data.m_implementationTimeout)
{
Vector3 onSphere1 = targetData.m_targetPosition + Random.onUnitSphere * m_radiusLB;
Vector3 onSphere2 = targetData.m_targetPosition + Random.onUnitSphere * m_radiusUB;
finalPosition = Vector3.Lerp(onSphere1, onSphere2, Random.value);
finalRotation = Quaternion.LookRotation(targetData.m_targetPosition - finalPosition);
if (CheckVisibility(data, currentNode, finalPosition, finalRotation, targetData))
{
SetSimulationData(currentNode, finalPosition, finalRotation, data.m_defaultFOV);
return(true);
}
counter++;
}
SetSimulationData(currentNode, finalPosition, finalRotation, data.m_defaultFOV);
return(false);
}
protected bool CheckVisibility(StoryboardData data, StoryboardNode currentnode, Vector3 finalPosition, Quaternion finalRotation, SimulationTargetData targetData)
{
ProxySet proxySet = data.m_proxySets[currentnode.m_index];
if (proxySet.CheckIfContains(finalPosition))
{
return(false);
}
RaycastHit hit;
Vector3 dir = (targetData.m_targetPosition - finalPosition);
if (Physics.SphereCast(finalPosition, data.m_visibilityCapsuleRadius, dir.normalized, out hit, dir.magnitude))
{
if (targetData.m_target != null && hit.transform == targetData.m_target)
{
return(true);
}
else if (targetData.m_target != null && hit.transform != targetData.m_target)
{
return(Vector3.Distance(hit.point, targetData.m_target.position) < data.m_visibilityContactThreshold);
}
else if (targetData.m_target == null)
{
return(Vector3.Distance(hit.point, targetData.m_targetPosition) < data.m_visibilityContactThreshold);
}
else
{
return(false);
}
}
return(true);
}
public override bool Simulate(StoryboardData data, StoryboardNode currentNode, StoryboardNode nextNode, SimulationTargetData targetData)
{
float distance = 0.0f;
Vector3 fwPosition = Vector3.zero;
Vector3 rightPosition = Vector3.zero;
Vector3 leftPosition = Vector3.zero;
Vector3 upPosition = Vector3.zero;
Vector3 downPosition = Vector3.zero;
Vector3 finalPosition = Vector3.zero;
Quaternion finalRotation = Quaternion.identity;
int counter = 0;
while (counter < data.m_implementationTimeout)
{
float t = Random.Range(-m_xArc, m_xArc);
distance = Random.Range(m_distanceLB, m_distanceUB);
fwPosition = targetData.m_targetPosition + targetData.m_targetForward * distance;
rightPosition = targetData.m_targetPosition + targetData.m_targetRight * distance;
leftPosition = targetData.m_targetPosition + -targetData.m_targetRight * distance;
upPosition = targetData.m_targetPosition + targetData.m_targetUp * distance;
downPosition = targetData.m_targetPosition + -targetData.m_targetUp * distance;
finalPosition = fwPosition;
if (t > 0)
{
finalPosition = MathUtility.SampleParabola(fwPosition, leftPosition, m_arcHeight, t, Quaternion.LookRotation(leftPosition - finalPosition) * Vector3.right);
}
else
{
finalPosition = MathUtility.SampleParabola(fwPosition, rightPosition, m_arcHeight, -t, Quaternion.LookRotation(rightPosition - finalPosition) * Vector3.left);
}
t = Random.Range(-m_yArc, m_yArc);
if (t > 0)
{
finalPosition = MathUtility.SampleParabola(finalPosition, upPosition, m_arcHeight, t, Quaternion.LookRotation(upPosition - finalPosition) * Vector3.up);
}
else
{
finalPosition = MathUtility.SampleParabola(finalPosition, downPosition, m_arcHeight, -t, Quaternion.LookRotation(downPosition - finalPosition) * Vector3.down);
}
finalRotation = Quaternion.LookRotation(targetData.m_targetPosition - finalPosition);
if (CheckVisibility(data, currentNode, finalPosition, finalRotation, targetData))
{
SetSimulationData(currentNode, finalPosition, finalRotation, data.m_defaultFOV);
return(true);
}
counter++;
}
SetSimulationData(currentNode, finalPosition, finalRotation, data.m_defaultFOV);
return(false);
}
public IEnumerator CalculateSceneProxies(StoryboardWindow window, StoryboardData data, TimelineAsset timeline, PlayableDirector playable, Vector3 position, Vector3 sceneProxyBounds)
{
data.m_proxySets.Clear();
IEnumerable <IMarker> markers = timeline.markerTrack.GetMarkers();
markers = markers.OrderBy(a => a.time);
IEnumerator markersIt = markers.GetEnumerator();
while (markersIt.MoveNext())
{
if (markersIt.Current is StoryboardMarker marker)
{
playable.time = marker.m_jumpsToTime ? marker.m_jumpTime : marker.time;
playable.Evaluate();
yield return(null);
ProxySet set = new ProxySet();
set.m_proxies = new List <Proxy>();
Collider[] colliders = Physics.OverlapBox(position, sceneProxyBounds / 2.0f);
for (int i = 0; i < colliders.Length; i++)
{
Proxy proxy = new Proxy();
Collider col = colliders[i];
proxy.m_collider = colliders[i];
proxy.m_gameObjectID = proxy.m_collider.gameObject.GetInstanceID().ToString();
set.m_proxies.Add(proxy);
}
yield return(null);
set.m_marker = marker;
data.m_proxySets.Add(set);
}
}
playable.time = 0.0;
playable.Evaluate();
window.OnProxyCalculationEnd();
}
public override bool Simulate(StoryboardData data, StoryboardNode currentNode, StoryboardNode nextNode, SimulationTargetData targetData)
{
return(true);
}
public void PlayStory(StoryboardData storyboardData)
{
StoryboardPanel.StoryboardData = storyboardData;
StoryboardPanel.CreateStoryBoard();
}
private bool DrawGeneralProperties()
{
float controlWidth = m_propertyPanelWidth - m_panelsSpacing * 2 - 10;
EditorGUILayout.BeginVertical("GroupBox", GUILayout.MaxWidth(controlWidth));
EditorGUILayout.LabelField("General", m_resources.m_smallLabel);
EditorGUILayout.Space(5);
m_storyboardData = EditorGUILayout.ObjectField("Target Data", m_storyboardData, typeof(StoryboardData), true) as StoryboardData;
if (m_storyboardData == null)
{
EditorGUILayout.Space(10);
EditorGUILayout.HelpBox("No storyboard data is assigned, please assign one to continue operations.", MessageType.Error, true);
return(false);
}
m_lastStoryboardDataPath = AssetDatabase.GetAssetPath(m_storyboardData);
m_timeline = EditorGUILayout.ObjectField("Timeline", m_timeline, typeof(TimelineAsset), true) as TimelineAsset;
if (m_timeline == null)
{
EditorGUILayout.Space(10);
EditorGUILayout.HelpBox("No timeline asset is assigned, please assign one to continue operations.", MessageType.Error);
return(false);
}
m_lastTimelinePath = AssetDatabase.GetAssetPath(m_timeline);
m_playableDirector = EditorGUILayout.ObjectField("Playable Director", m_playableDirector, typeof(PlayableDirector), true) as PlayableDirector;
if (m_playableDirector == null)
{
EditorGUILayout.Space(10);
EditorGUILayout.HelpBox("No playable director is referenced, please assign one to continue operations.", MessageType.Error);
return(false);
}
m_playController = EditorGUILayout.ObjectField("Play Controller", m_playController, typeof(StoryboardPlayController), true) as StoryboardPlayController;
if (m_playController == null)
{
EditorGUILayout.Space(10);
EditorGUILayout.HelpBox("No play controller is referenced, please assign one to continue operations.", MessageType.Error);
return(false);
}
m_camera = EditorGUILayout.ObjectField("Camera", m_camera, typeof(Camera), true) as Camera;
m_playController.m_camera = m_camera;
if (m_camera == null)
{
EditorGUILayout.Space(10);
EditorGUILayout.HelpBox("No camera transform is referenced, please assign one to continue operations.", MessageType.Error);
return(false);
}
m_sceneProxy = EditorGUILayout.ObjectField("Scene Proxy", m_sceneProxy, typeof(StoryboardSceneProxy), true) as StoryboardSceneProxy;
if (m_sceneProxy == null)
{
EditorGUILayout.Space(10);
EditorGUILayout.HelpBox("No scene proxy is referenced, please assign one to continue operations.", MessageType.Error);
return(false);
}
m_directorDataTextAsset = EditorGUILayout.ObjectField("Director Data", m_directorDataTextAsset, typeof(TextAsset), true) as TextAsset;
if (m_directorDataTextAsset == null)
{
EditorGUILayout.Space(10);
EditorGUILayout.HelpBox("No director threshold data is referenced, please assign one to continue operations.", MessageType.Error);
return(false);
}
m_lastDirectorThresholdsPath = AssetDatabase.GetAssetPath(m_directorDataTextAsset);
m_renderTexture = EditorGUILayout.ObjectField("Screenshot RT", m_renderTexture, typeof(RenderTexture), true, GUILayout.MaxHeight(16)) as RenderTexture;
if (m_renderTexture == null)
{
EditorGUILayout.Space(10);
EditorGUILayout.HelpBox("No render texture is referenced, please assign one to continue operations.", MessageType.Error);
return(false);
}
m_lastRenderTexturePath = AssetDatabase.GetAssetPath(m_renderTexture);
m_dataDumpPath = EditorGUILayout.TextField("Data Dump Path", m_dataDumpPath);
if (!AssetDatabase.IsValidFolder(m_dataDumpPath))
{
EditorGUILayout.Space(10);
EditorGUILayout.HelpBox("Data dump path does not exist, please provide a valid path.", MessageType.Error);
return(false);
}
m_implementationResourcesPath = EditorGUILayout.TextField("Implementations Path", m_implementationResourcesPath);
if (!AssetDatabase.IsValidFolder(m_implementationResourcesPath))
{
EditorGUILayout.Space(10);
EditorGUILayout.HelpBox("Implementations path does not exist, please provide a valid path.", MessageType.Error);
return(false);
}
m_debugPositioning = EditorGUILayout.TextField("Debug Positioning", m_debugPositioning);
m_debugLook = EditorGUILayout.TextField("Debug Look", m_debugLook);
m_debugTrack = EditorGUILayout.TextField("Debug Track", m_debugTrack);
m_debugFX = EditorGUILayout.TextField("Debug FX", m_debugFX);
EditorGUILayout.Space(5);
EditorGUILayout.EndVertical();
return(true);
}
private void FindReferences()
{
if (m_timeline == null)
{
m_timeline = AssetDatabase.LoadAssetAtPath <TimelineAsset>(m_lastTimelinePath);
}
if (m_storyboardData == null)
{
m_storyboardData = AssetDatabase.LoadAssetAtPath <StoryboardData>(m_lastStoryboardDataPath);
}
if (m_sceneProxy == null)
{
m_sceneProxy = GameObject.FindObjectOfType <StoryboardSceneProxy>();
}
if (m_directorDataTextAsset == null)
{
m_directorDataTextAsset = AssetDatabase.LoadAssetAtPath <TextAsset>(m_lastDirectorThresholdsPath);
}
if (m_renderTexture == null)
{
m_renderTexture = AssetDatabase.LoadAssetAtPath <RenderTexture>(m_lastRenderTexturePath);
}
if (m_playController == null)
{
m_playController = FindObjectOfType <StoryboardPlayController>();
}
if (m_playableDirector == null)
{
PlayableDirector[] directors = FindObjectsOfType <PlayableDirector>();
for (int i = 0; i < directors.Length; i++)
{
if (directors[i].playableAsset == m_timeline)
{
m_playableDirector = directors[i];
break;
}
}
}
if (m_camera == null)
{
StoryboardTargetCamera targetCam = FindObjectOfType <StoryboardTargetCamera>();
if (targetCam != null && m_playController != null)
{
m_camera = targetCam.GetComponent <Camera>();
m_playController.m_camera = m_camera;
}
}
else if (m_camera.GetComponent <Camera>() == null)
{
m_camera = null;
}
if (m_storyboardData.m_techniqueImplementations == null)
{
m_storyboardData.m_directorData.CreateImplementationDetails(m_implementationResourcesPath, ref m_storyboardData.m_techniqueImplementations);
}
}
public abstract bool Simulate(StoryboardData data, StoryboardNode currentNode, StoryboardNode nextNode, SimulationTargetData targetData);
public bool Simulate(StoryboardWindow window, Transform cameraTransform, StoryboardData data, TimelineAsset timeline, PlayableDirector playable,
ref int simulatedMarkerCount, string debugPositioning, string debugLook, string debugTrack, string debugFX, RenderTexture rt, bool simulateAll, int simulatedIndex = -1)
{
StoryboardNode previousNode = simulateAll ? null : (simulatedIndex == 0 ? null : data.m_nodes[simulatedIndex - 1]);
int iStart = simulateAll ? 0 : simulatedIndex;
int iEnd = simulateAll ? data.m_nodes.Count : simulatedIndex + 1;
for (int i = iStart; i < iEnd; i++)
{
StoryboardNode currentNode = data.m_nodes[i];
if (currentNode.m_isLocked)
{
previousNode = currentNode;
simulatedMarkerCount++;
continue;
}
// Calculate target position
SimulationTargetData targetData = new SimulationTargetData();
targetData.m_target = null;
targetData.m_targetForward = Vector3.forward;
targetData.m_targetRight = Vector3.right;
targetData.m_targetUp = Vector3.up;
targetData.m_targetPosition = Vector3.zero;
for (int j = 0; j < currentNode.m_marker.m_targets.Length; j++)
{
var objects = Resources.FindObjectsOfTypeAll <StoryboardTarget>().Where(obj => obj.gameObject.name == currentNode.m_marker.m_targets[j]);
if (objects.Count <StoryboardTarget>() > 1)
{
Debug.LogError("Multiple storyboard targets with the same name is found. Please make sure each target has a unique name to avoid any confusions.");
currentNode.m_simulationData = null;
data.m_nodes.Clear();
return(false);
}
GameObject go = GameObject.Find(currentNode.m_marker.m_targets[j]);
if (go == null)
{
Debug.LogError("The target " + currentNode.m_marker.m_targets[j] + " could not be found, aborting simulation.");
currentNode.m_simulationData = null;
data.m_nodes.Clear();
return(false);
}
targetData.m_targetPosition += go.transform.position;
if (currentNode.m_marker.m_targets.Length == 1)
{
targetData.m_target = go.transform;
targetData.m_targetPosition = targetData.m_target.position;
targetData.m_targetForward = targetData.m_target.forward;
targetData.m_targetRight = targetData.m_target.right;
targetData.m_targetUp = targetData.m_target.up;
}
}
// Finalize target position as mid point.
targetData.m_targetPosition /= currentNode.m_marker.m_targets.Length;
StoryboardDirectorData dirData = data.m_directorData;
DecisionTechniquePreference pref = data.m_decisionTechnique;
float dramThresh = data.m_dramatizationThreshold;
float paceThresh = data.m_paceThreshold;
bool useFX = data.m_useFX;
bool simulationSuccessful = false;
int timeoutCounter = 0;
StoryboardNode nextNode = i < data.m_nodes.Count - 1 ? data.m_nodes[i + 1] : null;
while (!simulationSuccessful && timeoutCounter < data.m_techniqueTimeout)
{
currentNode.m_positioningTechnique = GetTechnique("Positioning", previousNode, currentNode, dirData, pref, dramThresh, paceThresh, useFX);
currentNode.m_simulationData = new SimulationData();
simulationSuccessful = currentNode.m_positioningTechnique.m_implementation.Simulate(data, currentNode, nextNode, targetData);
timeoutCounter++;
}
// Set simulation's target data.
currentNode.m_simulationData.m_targetData = targetData;
//currentNode.m_lookTechnique = GetTechnique("Look", previousNode, currentNode, dirData, pref, dramThresh, paceThresh, useFX);
//currentNode.m_trackTechnique = GetTechnique("Track", previousNode, currentNode, dirData, pref, dramThresh, paceThresh, useFX);
//currentNode.m_fxTechnique = GetTechnique("FX", previousNode, currentNode, dirData, pref, dramThresh, paceThresh, useFX);
// D E B U G
if (debugPositioning != "")
{
currentNode.m_trackTechnique = data.m_directorData.m_categories[0].m_techniques.Find(o => o.m_title.CompareTo(debugPositioning) == 0);
}
if (debugLook != "")
{
currentNode.m_lookTechnique = data.m_directorData.m_categories[1].m_techniques.Find(o => o.m_title.CompareTo(debugLook) == 0);
}
if (debugTrack != "")
{
currentNode.m_trackTechnique = data.m_directorData.m_categories[2].m_techniques.Find(o => o.m_title.CompareTo(debugTrack) == 0);
}
if (debugFX != "")
{
currentNode.m_fxTechnique = data.m_directorData.m_categories[3].m_techniques.Find(o => o.m_title.CompareTo(debugFX) == 0);
}
ApplySimulationPropertiesToCamera(currentNode.m_simulationData, cameraTransform);
currentNode.m_simulationData.m_snapshots.Add(TakeCameraSnapshot(cameraTransform.GetComponent <Camera>(), rt));
previousNode = currentNode;
simulatedMarkerCount++;
targetData = null;
}
// Make sure we reset back the playable.
playable.time = 0.0;
playable.Evaluate();
window.OnSimulationEnd();
return(true);
}
public bool FillStoryboardNodes(StoryboardData storyboardData, TimelineAsset timeline, string dataDumpPath)
{
// Save locked nodes.
List <StoryboardNode> lockedNodes = new List <StoryboardNode>();
for (int i = 0; i < storyboardData.m_nodes.Count; i++)
{
StoryboardNode currentNode = storyboardData.m_nodes[i];
if (currentNode.m_isLocked)
{
lockedNodes.Add(currentNode);
}
else
{
for (int j = 0; j < currentNode.m_simulationData.m_snapshots.Count; j++)
{
string path = AssetDatabase.GetAssetPath(currentNode.m_simulationData.m_snapshots[j]);
AssetDatabase.DeleteAsset(path);
AssetDatabase.Refresh();
}
}
}
// First fill the nodes with markers.
storyboardData.m_nodes.Clear();
IEnumerable <IMarker> markers = timeline.markerTrack.GetMarkers();
markers = markers.OrderBy(a => a.time);
IEnumerator markersIt = markers.GetEnumerator();
int index = 0;
while (markersIt.MoveNext())
{
if (markersIt.Current is StoryboardMarker marker)
{
int foundIndex = lockedNodes.FindIndex(o => o.m_marker == marker);
if (foundIndex > -1)
{
if (lockedNodes[foundIndex].m_index != index)
{
for (int j = 0; j < lockedNodes[foundIndex].m_simulationData.m_snapshots.Count; j++)
{
string assetPath = dataDumpPath + "/" + storyboardData.name + "_node_" + lockedNodes[foundIndex].m_index.ToString() + "_" + j.ToString() + ".texture2d";
string newPath = storyboardData.name + "_node_" + index.ToString() + "_" + j.ToString() + ".texture2d";
string msg = AssetDatabase.RenameAsset(assetPath, newPath);
AssetDatabase.SaveAssets();
}
}
lockedNodes[foundIndex].m_index = index;
storyboardData.m_nodes.Add(lockedNodes[foundIndex]);
}
else
{
storyboardData.m_nodes.Add(new StoryboardNode());
StoryboardNode node = storyboardData.m_nodes.Last();
node.m_marker = marker;
node.m_index = index;
}
index++;
}
}
return(storyboardData.m_nodes.Count != 0);
}
