Pop_Slime/crtr
1
0
Fork 0
Code Issues 6 Pull Requests Projects 1 Releases Activity

Restructure event/container system.

Browse Source
This commit is contained in:
PopSlime
2023-01-31 15:53:43 +08:00
parent 9700992c3a
commit a1ce459a0e
9 changed files with 241 additions and 223 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Assets/Cryville/Crtr/ChartHandler.cs
View File

@@ -40,8 +40,8 @@ namespace Cryville.Crtr {
}
}
public override void EndUpdate(ContainerState s) {
base.EndUpdate(s);
public override void EndLogicalUpdate(ContainerState s) {
base.EndLogicalUpdate(s);
// TODO End of chart
}

4
Assets/Cryville/Crtr/ChartPlayer.cs
View File

@@ -148,13 +148,13 @@ namespace Cryville.Crtr {
actualRenderStep = step;
nbus.ForwardStepByTime(clippingDist, step);
nbus.BroadcastEndUpdate();
nbus.EndPreGraphicalUpdate();
nbus.Anchor();
tbus.StripTempEvents();
tbus.ForwardStepByTime(clippingDist, step);
tbus.ForwardStepByTime(renderDist, step);
tbus.BroadcastEndUpdate();
tbus.EndGraphicalUpdate();
UnityEngine.Profiling.Profiler.EndSample();
}
catch (Exception ex) {

85
Assets/Cryville/Crtr/Event/ContainerHandler.cs
View File

@@ -4,6 +4,7 @@ using Cryville.Crtr.Components;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Runtime.CompilerServices;
using UnityEngine;
namespace Cryville.Crtr.Event {
@@ -46,8 +47,20 @@ namespace Cryville.Crtr.Event {
public Vector3 Position { get; protected set; }
public Quaternion Rotation { get; protected set; }
public bool Alive { get; private set; }
public bool Awoken { get; private set; }
public bool Disposed { get; private set; }
bool PreGraphicalActive;
public void SetPreGraphicalActive(bool value, ContainerState s) {
if (PreGraphicalActive == value) return;
PreGraphicalActive = value;
if (PreGraphicalActive) StartPreGraphicalUpdate(s);
else EndPreGraphicalUpdate(s);
}
bool GraphicalActive;
public void SetGraphicalActive(bool value, ContainerState s) {
if (GraphicalActive == value) return;
GraphicalActive = value;
if (GraphicalActive) StartGraphicalUpdate(s);
else EndGraphicalUpdate(s);
}
public EventContainer Container {
get { return cs.Container; }
@@ -114,34 +127,27 @@ namespace Cryville.Crtr.Event {
gogroup.gameObject.SetActive(false);
}
#endregion
protected virtual void PreAwake(ContainerState s) {
if (gogroup) {
gogroup.gameObject.SetActive(true);
OpenAnchor(a_head);
}
Awoken = true; Alive = true;
}
protected virtual void Awake(ContainerState s) {
if (gogroup) CloseAnchor();
}
public virtual void StartUpdate(ContainerState s) {
if (s.CloneType >= 2 && s.CloneType < 16) {
PreAwake(s);
Awake(s);
}
else if (s.CloneType == 17) {
Init();
#region Start methods
public virtual void StartPhysicalUpdate(ContainerState s) {
if (s.CloneType < 16) Alive = true;
else if (s.CloneType == 17) Init();
}
public virtual void StartLogicalUpdate(ContainerState s) { }
public virtual void StartPreGraphicalUpdate(ContainerState s) { }
public virtual void StartGraphicalUpdate(ContainerState s) {
if (gogroup) gogroup.gameObject.SetActive(true);
}
#endregion
public virtual void Update(ContainerState s, StampedEvent ev) {
bool flag = !Awoken && s.CloneType >= 2 && s.CloneType < 16;
if (flag) PreAwake(s);
if (gogroup && s.CloneType <= 2) skinContainer.MatchDynamic(s);
if (flag) Awake(s);
}
public virtual void ExUpdate(ContainerState s, StampedEvent ev) {
if (ev is StampedEvent.Anchor) {
if (s.CloneType == 3) SetPreGraphicalActive(true, s);
else if (ev is StampedEvent.Anchor) {
var tev = (StampedEvent.Anchor)ev;
if (tev.Target == a_head) {
SetGraphicalActive(true, s);
}
else if (tev.Target == a_tail) {
SetGraphicalActive(false, s);
}
if (gogroup) {
OpenAnchor(tev.Target);
#if UNITY_5_6_OR_NEWER
@@ -155,28 +161,31 @@ namespace Cryville.Crtr.Event {
}
anchorEvPool.Return(tev);
}
else if (gogroup && s.CloneType <= 2) skinContainer.MatchDynamic(s);
}
public virtual void MotionUpdate(byte ct, Chart.Motion ev) { }
public virtual void EndUpdate(ContainerState s) {
if (s.CloneType < 16) {
Awoken = false;
if (gogroup && s.CloneType <= 2) {
OpenAnchor(a_tail);
skinContainer.MatchDynamic(s);
CloseAnchor();
}
}
}
#region End methods
public virtual void EndGraphicalUpdate(ContainerState s) { }
public virtual void EndPreGraphicalUpdate(ContainerState s) { }
public virtual void EndLogicalUpdate(ContainerState s) { }
public virtual void EndPhysicalUpdate(ContainerState s) { }
public virtual void Dispose() {
if (gogroup)
GameObject.Destroy(gogroup.gameObject);
Alive = false;
}
public virtual void DisposeAll() { }
#endregion
[MethodImpl(MethodImplOptions.AggressiveInlining)]
protected static bool CanDoGraphicalUpdate(ContainerState s) { return s.CloneType >= 2 && s.CloneType < 16; }
#region Anchor
public virtual void Anchor() {
skinContainer.MatchDynamic(cs);
if (cs.Working) PushAnchorEvent(cs.Time, a_cur);
if (cs.Active) PushAnchorEvent(cs.Time, a_cur);
if (Alive) {
PushAnchorEvent(cs.StampedContainer.Time, a_head, -1, true);
PushAnchorEvent(cs.StampedContainer.Time + cs.StampedContainer.Duration, a_tail, 1, true);
}
}
static readonly SimpleObjectPool<StampedEvent.Anchor> anchorEvPool
= new SimpleObjectPool<StampedEvent.Anchor>(1024);
public void PushAnchorEvent(double time, int name) {

115
Assets/Cryville/Crtr/Event/ContainerState.cs
View File

@@ -3,6 +3,7 @@
using Cryville.Common;
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using UnityEngine;
namespace Cryville.Crtr.Event {
@@ -16,9 +17,7 @@ namespace Cryville.Crtr.Event {
public Dictionary<EventContainer, ContainerState> Children
= new Dictionary<EventContainer, ContainerState>();
readonly HashSet<EventContainer> WorkingChildren
= new HashSet<EventContainer>();
readonly HashSet<EventContainer> InvalidatedChildren
HashSet<EventContainer> ActiveChildren
= new HashSet<EventContainer>();
public Dictionary<Type, List<ContainerState>> TypedChildren
= new Dictionary<Type, List<ContainerState>>();
@@ -30,26 +29,45 @@ namespace Cryville.Crtr.Event {
return Children[ev];
}
void NotifyWorkingChanged(EventContainer key) {
InvalidatedChildren.Add(key);
private bool m_active;
public bool Active {
get { return m_active; }
private set {
if (m_active == value) return;
m_active = value;
if (!m_active && CloneType == 1) Dispose();
if (Parent != null) {
if (m_active) Parent.ActiveChildren.Add(Container);
else Parent.ActiveChildren.Remove(Container);
}
void ValidateChildren() {
foreach (var cev in InvalidatedChildren)
if (Children[cev].Working && !WorkingChildren.Contains(cev)) WorkingChildren.Add(cev);
else if (!Children[cev].Working && WorkingChildren.Contains(cev)) WorkingChildren.Remove(cev);
InvalidatedChildren.Clear();
Bus.NotifyActiveChanged(this);
}
public bool Active { get; set; }
private bool m_Working;
public bool Working {
get { return m_Working; }
}
private bool m_lActive;
public bool LogicalActive {
get { return m_lActive; }
set {
m_Working = value;
if (Parent != null) Parent.NotifyWorkingChanged(Container);
Bus.NotifyWorkingChanged(this);
if (m_lActive == value) return;
m_lActive = value;
UpdateActive();
if (m_lActive) Handler.StartLogicalUpdate(this);
else Handler.EndLogicalUpdate(this);
}
}
private bool m_pActive;
public bool PhysicalActive {
get { return m_pActive; }
set {
if (m_pActive == value) return;
m_pActive = value;
UpdateActive();
if (m_pActive) Handler.StartPhysicalUpdate(this);
else Handler.EndPhysicalUpdate(this);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
void UpdateActive() { Active = m_lActive || m_pActive; }
public byte CloneType;
public ContainerState rootPrototype = null;
private ContainerState prototype = null;
@@ -112,6 +130,8 @@ namespace Cryville.Crtr.Event {
AddChild(child.Key, cc, r);
}
r.ActiveChildren = new HashSet<EventContainer>();
var pms = new Dictionary<StampedEvent, RealtimeMotionValue>(Math.Max(4, PlayingMotions.Count));
foreach (var m in PlayingMotions)
pms.Add(m.Key, m.Value);
@@ -128,7 +148,10 @@ namespace Cryville.Crtr.Event {
}
public void CopyTo(byte ct, ContainerState dest) {
dest.Working = Working;
dest.m_lActive = m_lActive;
dest.m_pActive = m_pActive;
dest.m_active = m_active;
if (dest.m_active) dest.Bus.NotifyActiveChanged(dest);
foreach (var mv in Values) {
RealtimeMotionValue dv;
@@ -145,11 +168,15 @@ namespace Cryville.Crtr.Event {
cv.Value.CopyTo(dv);
}
if (ct != 1) foreach (var cev in WorkingChildren)
foreach (var cev in dest.ActiveChildren) {
if (!ActiveChildren.Contains(cev))
Children[cev].CopyTo(ct, dest.Children[cev]);
else foreach (var child in Children)
child.Value.CopyTo(ct, dest.Children[child.Key]);
dest.ValidateChildren();
}
dest.ActiveChildren.Clear();
foreach (var cev in ActiveChildren) {
dest.ActiveChildren.Add(cev);
Children[cev].CopyTo(ct, dest.Children[cev]);
}
dest.PlayingMotions.Clear();
foreach (var m in PlayingMotions) dest.PlayingMotions.Add(m.Key, m.Value);
@@ -312,9 +339,9 @@ namespace Cryville.Crtr.Event {
bool breakflag = false;
public void Break() {
Handler.EndUpdate(this);
// Handler.EndLogicalUpdate(this);
breakflag = true;
Working = false;
// LogicalActive = false;
}
public void Discard(StampedEvent ev) {
@@ -339,18 +366,14 @@ namespace Cryville.Crtr.Event {
else if (ev.Unstamped is EventContainer) {
var cev = (EventContainer)ev.Unstamped;
var ccs = GetChild(cev);
ccs.Working = true;
ccs.StartUpdate();
ccs.LogicalActive = true;
UpdateMotions();
if (!cev.IsLong) {
ccs.Working = false;
ccs.BroadcastEndUpdate();
if (CloneType == 1) ccs.Dispose();
ccs.LogicalActive = false;
}
}
else if (ev.Unstamped is InstantEvent) {
var tev = (InstantEvent)ev.Unstamped;
if (tev.IsRelease) {
else if (ev.Unstamped is ReleaseEvent) {
var tev = (ReleaseEvent)ev.Unstamped;
var nev = tev.Original;
if (nev is Chart.Motion) {
Update(ev);
@@ -362,10 +385,7 @@ namespace Cryville.Crtr.Event {
var cev = (EventContainer)ev.Origin.Unstamped;
var ccs = GetChild(cev);
UpdateMotions();
ccs.Working = false;
ccs.BroadcastEndUpdate();
if (CloneType == 1) ccs.Dispose();
}
ccs.LogicalActive = false;
}
}
Update(ev.Unstamped == null || ev.Unstamped.Priority >= 0 ? ev : null);
@@ -373,12 +393,10 @@ namespace Cryville.Crtr.Event {
else Update(null);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
void Update(StampedEvent ev) {
UpdateMotions();
if (ev == null || ev.Unstamped != null) Handler.Update(this, ev);
else Handler.ExUpdate(this, ev);
foreach (var m in PlayingMotions)
Handler.MotionUpdate(CloneType, (Chart.Motion)m.Key.Unstamped);
Handler.Update(this, ev);
}
private void UpdateMotions() {
@@ -423,14 +441,17 @@ namespace Cryville.Crtr.Event {
}
}
public void StartUpdate() {
Handler.StartUpdate(this);
public void EndPreGraphicalUpdate() {
Handler.SetPreGraphicalActive(false, this);
foreach (var ls in ActiveChildren) {
Children[ls].EndPreGraphicalUpdate();
}
}
public void BroadcastEndUpdate() {
Handler.EndUpdate(this);
foreach (var ls in Children.Values) {
if (ls.Working) ls.BroadcastEndUpdate();
public void EndGraphicalUpdate() {
Handler.SetGraphicalActive(false, this);
foreach (var ls in ActiveChildren) {
Children[ls].EndGraphicalUpdate();
}
}

23
Assets/Cryville/Crtr/Event/EventBatcher.cs
View File

@@ -84,15 +84,34 @@ namespace Cryville.Crtr.Event {
Container = con
};
if (ev is EventContainer) {
stateMap[(EventContainer)ev].StampedContainer = sev;
var tev = (EventContainer)ev;
stateMap[tev].StampedContainer = sev;
stampedEvents.Add(new StampedEvent.ClipBehind {
Container = con,
Origin = sev,
Time = etime + tev.Clip.Behind,
});
if (!ev.IsLong) {
stampedEvents.Add(new StampedEvent.ClipAhead {
Container = con,
Origin = sev,
Time = etime + tev.Clip.Ahead,
});
}
}
if (ev is InstantEvent) {
if (ev is ReleaseEvent) {
var tev = (ReleaseEvent)ev;
var oev = tev.Original;
var pev = map[oev];
pev.ReleaseEvent = sev;
sev.Origin = pev;
if (oev is EventContainer) {
stampedEvents.Add(new StampedEvent.ClipAhead {
Container = con,
Origin = pev,
Time = etime + ((EventContainer)oev).Clip.Ahead,
});
}
}
if (con != null && coevents.Contains(ev)) {
List<StampedEvent> cevs;

76
Assets/Cryville/Crtr/Event/EventBus.cs
View File

@@ -11,31 +11,27 @@ namespace Cryville.Crtr.Event {
Dictionary<EventContainer, ContainerState> states
= new Dictionary<EventContainer, ContainerState>();
HashSet<EventContainer> activeContainers
= new HashSet<EventContainer>();
HashSet<ContainerState> workingStates
HashSet<ContainerState> activeStates
= new HashSet<ContainerState>();
HashSet<ContainerState> invalidatedStates
= new HashSet<ContainerState>();
public int ActiveStateCount { get { return activeStates.Count; } }
public EventBus(ContainerState root, List<EventBatch> b) : base(b) {
RootState = root;
Expand();
AttachBus();
RootState.Working = true;
}
public EventBus Clone(byte ct, float offsetTime = 0) {
var r = (EventBus)MemberwiseClone();
r.prototype = this;
r.states = new Dictionary<EventContainer, ContainerState>();
r.activeContainers = new HashSet<EventContainer>();
r.workingStates = new HashSet<ContainerState>();
r.activeStates = new HashSet<ContainerState>();
r.invalidatedStates = new HashSet<ContainerState>();
r.tempEvents = new List<StampedEvent>();
r.tempEvents = new List<StampedEvent.Temporary>();
r.Time += offsetTime;
r.RootState = RootState.Clone(ct);
r.RootState.StartUpdate();
r.Expand();
r.AttachBus();
foreach (var s in r.states) r.invalidatedStates.Add(s.Value);
@@ -45,18 +41,9 @@ namespace Cryville.Crtr.Event {
public void CopyTo(byte ct, EventBus dest) {
base.CopyTo(dest);
dest.workingStates.Clear();
dest.activeStates.Clear();
dest.invalidatedStates.Clear();
RootState.CopyTo(ct, dest.RootState);
if (ct >= 2) {
dest.activeContainers.Clear();
foreach (var c in activeContainers) {
if (states[c].Working) {
states[c].CopyTo(ct, dest.states[c]);
dest.activeContainers.Add(c);
}
}
}
dest.ValidateStates();
}
@@ -67,7 +54,7 @@ namespace Cryville.Crtr.Event {
RootState.DisposeAll();
}
public void NotifyWorkingChanged(ContainerState state) {
public void NotifyActiveChanged(ContainerState state) {
if (!invalidatedStates.Contains(state)) invalidatedStates.Add(state);
}
@@ -86,22 +73,6 @@ namespace Cryville.Crtr.Event {
s.Bus = this;
}
void EnsureActivity(EventContainer c) {
if (activeContainers.Contains(c)) return;
var state = states[c];
if (state.Parent != null) EnsureActivity(state.Parent.Container);
if (RootState.CloneType >= 2) prototype.states[c].CopyTo(RootState.CloneType, state);
state.Active = true;
activeContainers.Add(c);
if (state.StampedContainer.Coevents == null) return;
foreach (var cev in state.StampedContainer.Coevents) {
if (cev.Container == null) continue;
EnsureActivity(cev.Container);
states[cev.Container].Handle(cev);
}
}
void AttachBus() {
foreach (var s in states.Values)
s.Bus = this;
@@ -145,18 +116,26 @@ namespace Cryville.Crtr.Event {
double time0 = Math.Min(time1, time2);
if (time0 <= toTime && time0 != double.PositiveInfinity) {
Time = time0;
foreach (var s in workingStates) s.Handle(null);
foreach (var s in activeStates) s.Handle(null);
ValidateStates();
if (time1 == time0) {
var batch = Events[EventId];
for (var i = 0; i < batch.Count; i++) {
var ev = batch[i];
if (ev.Container != null) {
if (ev.Unstamped is EventContainer) EnsureActivity((EventContainer)ev.Unstamped);
else EnsureActivity(ev.Container);
if (ev is StampedEvent.ClipBehind) {
var cevs = ev.Origin.Coevents;
if (cevs != null) foreach (var cev in cevs) {
if (cev.Container == null) continue;
states[cev.Container].Handle(cev);
}
states[(EventContainer)ev.Origin.Unstamped].PhysicalActive = true;
}
else if (ev is StampedEvent.ClipAhead) {
states[(EventContainer)ev.Origin.Unstamped].PhysicalActive = false;
}
else if (ev.Container != null) {
states[ev.Container].Handle(ev);
}
else if (ev.Coevents != null) EnsureActivity((EventContainer)ev.Unstamped);
}
EventId++;
}
@@ -165,25 +144,23 @@ namespace Cryville.Crtr.Event {
var ev = tempEvents[0];
if (ev.Time != time0) break;
if (ev.Container != null) {
EnsureActivity(ev.Container);
states[ev.Container].Handle(ev);
}
tempEvents.RemoveAt(0);
}
}
ValidateStates();
}
else {
Time = toTime;
foreach (var s in workingStates) s.Handle(null);
ValidateStates();
foreach (var s in activeStates) s.Handle(null);
}
ValidateStates();
}
private void ValidateStates() {
foreach (var s in invalidatedStates)
if (s.Working && !workingStates.Contains(s)) workingStates.Add(s);
else if (!s.Working && workingStates.Contains(s)) workingStates.Remove(s);
if (s.Active && !activeStates.Contains(s)) activeStates.Add(s);
else if (!s.Active && activeStates.Contains(s)) activeStates.Remove(s);
invalidatedStates.Clear();
}
@@ -194,8 +171,11 @@ namespace Cryville.Crtr.Event {
RootState.BroadcastPostInit();
}
public void BroadcastEndUpdate() {
RootState.BroadcastEndUpdate();
public void EndPreGraphicalUpdate() {
RootState.EndPreGraphicalUpdate();
}
public void EndGraphicalUpdate() {
RootState.EndGraphicalUpdate();
foreach (var ev in tempEvents) {
if (ev.Container != null) {
states[ev.Container].Discard(ev);

48
Assets/Cryville/Crtr/NoteHandler.cs
View File

@@ -59,19 +59,17 @@ namespace Cryville.Crtr {
sgos = gogroup.GetComponentsInChildren<SectionalGameObject>();
foreach (var judge in judges.Values) judge.InitPropSrcs();
}
protected override void PreAwake(ContainerState s) {
base.PreAwake(s);
#if UNITY_5_6_OR_NEWER
a_head.Transform.SetPositionAndRotation(Position = GetFramePoint(s.Parent, s.Track), Rotation = GetFrameRotation(s.Parent, s.Track));
#else
a_head.Transform.position = Position = GetFramePoint(s.Parent, s.Track);
a_head.Transform.rotation = Rotation = GetFrameRotation(s.Parent, s.Track);
#endif
}
protected override void Awake(ContainerState s) {
base.Awake(s);
public override void StartPhysicalUpdate(ContainerState s) {
base.StartPhysicalUpdate(s);
if (s.CloneType == 2) {
if (!gogroup) return;
TransformAwake(s);
}
}
public override void StartGraphicalUpdate(ContainerState s) {
base.StartGraphicalUpdate(s);
TransformAwake(s);
if (gogroup) {
if (Event.IsLong) {
foreach (var i in sgos) {
i.Reset();
@@ -88,17 +86,18 @@ namespace Cryville.Crtr {
}
}
}
void TransformAwake(ContainerState s) {
Position = GetFramePoint(s.Parent, s.Track);
Rotation = GetFrameRotation(s.Parent, s.Track);
}
public override void Update(ContainerState s, StampedEvent ev) {
base.Update(s, ev);
if (s.CloneType <= 2) {
Position = GetFramePoint(s.Parent, s.Track);
Rotation = GetFrameRotation(s.Parent, s.Track);
}
if (s.CloneType == 2) {
if (!gogroup) return;
Chart.Note tev = Event;
if (tev.IsLong) {
if (!gogroup || !Event.IsLong) return;
foreach (var i in sgos)
i.AppendPoint(Position, Rotation);
}
@@ -116,22 +115,11 @@ namespace Cryville.Crtr {
}
}
public override void Anchor() {
base.Anchor();
// TODO Push Dynamic Anchor Events
}
public override void EndUpdate(ContainerState s) {
if (s.CloneType == 2 && gogroup) {
public override void EndGraphicalUpdate(ContainerState s) {
if (gogroup) {
foreach (var i in sgos) i.Seal();
#if UNITY_5_6_OR_NEWER
a_tail.Transform.SetPositionAndRotation(GetFramePoint(ts.Parent, ts.Track), Quaternion.Euler(ts.Direction));
#else
a_tail.Transform.position = GetFramePoint(ts.Parent, ts.Track);
a_tail.Transform.rotation = Quaternion.Euler(ts.Direction);
#endif
}
base.EndUpdate(s);
base.EndGraphicalUpdate(s);
}
Vector3 GetFramePoint(ContainerState state, float track) {

10
Assets/Cryville/Crtr/StampedEvent.cs
View File

@@ -39,8 +39,16 @@ namespace Cryville.Crtr {
public override int Priority { get { return m_priority; } }
public void SetPriority(int value) { m_priority = value; }
}
public class ClipBehind : StampedEvent {
public override int Priority {
get { return 0; }
get { return Origin.Priority - 0x8000; }
}
}
public class ClipAhead : StampedEvent {
public override int Priority {
get { return 0x7fff - Origin.Priority; }
}
}

61
Assets/Cryville/Crtr/TrackHandler.cs
View File

@@ -21,34 +21,37 @@ namespace Cryville.Crtr {
SectionalGameObject[] sgos;
Vector3 bpos; Quaternion brot;
Vector3 spos;
protected override void PreAwake(ContainerState s) {
base.PreAwake(s);
pwp = Vector3.zero;
cpt = s.ScreenPoint;
ptime = s.Time;
if (s.CloneType == 2) {
#if UNITY_5_6_OR_NEWER
a_head.Transform.SetPositionAndRotation(GetCurrentWorldPoint(), Quaternion.Euler(s.Direction));
#else
a_head.Transform.position = GetCurrentWorldPoint();
a_head.Transform.rotation = Quaternion.Euler(s.Direction);
#endif
}
else if (s.CloneType == 3) {
spos = Vector3.zero;
bpos = cpt;
brot = Quaternion.Euler(s.Direction);
public override void StartPhysicalUpdate(ContainerState s) {
base.StartPhysicalUpdate(s);
if (CanDoGraphicalUpdate(s)) {
TransformAwake(s);
}
}
protected override void Awake(ContainerState s) {
base.Awake(s);
if (!gogroup) return;
public override void StartPreGraphicalUpdate(ContainerState s) {
base.StartPreGraphicalUpdate(s);
TransformAwake(s);
}
public override void StartGraphicalUpdate(ContainerState s) {
base.StartGraphicalUpdate(s);
if (gogroup) {
TransformAwake(s);
var p = GetCurrentWorldPoint();
foreach (var i in sgos) {
i.Reset();
i.AppendPoint(p, s.QuatDir);
}
}
}
void TransformAwake(ContainerState s) {
pwp = Vector3.zero;
cpt = s.ScreenPoint;
ptime = s.Time;
if (s.CloneType == 3) {
spos = Vector3.zero;
bpos = cpt;
brot = Quaternion.Euler(s.Direction);
}
}
Vector3 cpt; // Current point
Vector3 ppt = Vector3.zero; // Previous point
@@ -58,7 +61,7 @@ namespace Cryville.Crtr {
public override void Update(ContainerState s, StampedEvent ev) {
base.Update(s, ev);
if (s.CloneType == 2 || s.CloneType == 3) {
if (CanDoGraphicalUpdate(s)) {
var tpt = s.ScreenPoint;
var tsv = s.ScrollVelocity;
@@ -102,24 +105,14 @@ namespace Cryville.Crtr {
spos = bpos - GetCurrentWorldPoint();
}
public override void EndUpdate(ContainerState s) {
base.EndUpdate(s);
if (s.CloneType == 0 || s.CloneType == 2) {
EndUpdatePosition(ts);
public override void EndGraphicalUpdate(ContainerState s) {
base.EndGraphicalUpdate(s);
EndUpdatePosition(s);
var p = GetCurrentWorldPoint();
foreach (var i in sgos) {
i.AppendPoint(p, s.QuatDir);
i.Seal();
}
#if UNITY_5_6_OR_NEWER
a_tail.Transform.SetPositionAndRotation(GetCurrentWorldPoint(), Quaternion.Euler(ts.Direction));
#else
a_tail.Transform.position = GetCurrentWorldPoint();
a_tail.Transform.rotation = Quaternion.Euler(ts.Direction);
#endif
}
else if (s.CloneType == 3) EndUpdatePosition(ns);
else if (s.CloneType >= 16) EndUpdatePosition(ps);
}
void EndUpdatePosition(ContainerState s) {