/// <summary>
///
/// </summary>
/// <param name="step"></param>
/// <param name="newTrack"></param>
/// <param name="transcen"></param>
/// <param name="reverse"></param>
/// <returns>cmd 를 소모해야하는지 여부. true일 경우 큐에서 날린다. false일 경우 날리지 않고 다음 프레임에 계속 체크해본다</returns>
bool _StepMove(int step, Data.Track newTrack, Data.TransitionScenario transcen, int newstep = -1, bool reverse = false)
{
//Debug.Log(string.Format("m_curTrackStep : {0}, step : {1}", m_curTrackStep, step));
if (m_curTrackStep == step) // 동일한 step으로 진행하는 요청이 들어온 경우엔 무시한다.
{
Debug.Log("[LibSequentia] same step");
return(true);
}
// 현재 진행중인 요청이 stepmove고, 한번 더 진행이 가능한 경우에는 따로 요청을 늘리지 않는다. (자연 -> 강제 전환으로 바꾸는 것임)
var stepMoveReq = m_reqQueue.Count > 0 ? m_reqQueue.Peek() as StepMoveRequest : null;
if (stepMoveReq != null && stepMoveReq.MoveOnceMore(reverse))
{
return(true);
}
if (stepMoveReq == null) // 현재 진행중인 요청이 stepmove가 아닌 경우에만 새 명령을 추가한다.
{
var newreq = new StepMoveRequest(this);
//var newstep = m_newTrackIsOn? m_newTrackStep : m_curTrackStep;
//newstep += reverse? -1 : 1;
newreq.Setup(step, newstep, reverse, newTrack, transcen);
m_reqQueue.Enqueue(newreq);
return(true);
}
else
{ // stepmove가 맞긴 맞는데 위 moveoncemore 를 실패한 경우라면, 이 명령은 소모해서는 안됨
return(false);
}
}
/// <summary>
/// 트랜지션 단계 진행. 새 트랙을 준비한다.
/// </summary>
/// <param name="newTrack"></param>
/// <param name="transcen"></param>
/// <param name="reverse"></param>
public void StepMove(int step, Data.Track newTrack, Data.TransitionScenario transcen, int newstep = -1, bool reverse = false)
{
m_cmdQueue.Enqueue(new Command()
{
type = Command.Type.StepMove, param1 = step, param2 = newTrack, param3 = transcen, param4 = newstep, param5 = reverse
});
}
public void Setup(Data.Track curtrack, int curstep, Data.Track newtrack, int newstep, Data.TransitionScenario tscen)
{
m_curtrack = curtrack;
m_curstep = curstep;
m_newtrack = newtrack;
m_newstep = newstep;
m_tscen = tscen;
}
/// <summary>
/// 새 트랙 올리기. 재생은 하지 않음. 다음번 진행 타이밍에 맞춰서 시작
/// </summary>
/// <param name="track"></param>
public IMessageHandle[] SetNewTrack(Data.Track track, Data.TransitionScenario trans)
{
return(new IMessageHandle[]
{
EnqueAndMakeHandle(new Message()
{
type = Message.Type.NewTrack, parameter = track
}),
EnqueAndMakeHandle(new Message()
{
type = Message.Type.NewTransitionScenario, parameter = trans
}),
});
}
public void Setup(int targetStep, int newStep, bool reverse, Data.Track newtrack = null, Data.TransitionScenario trans = null)
{
// 새 트랙이 진행중이면서 진행방향이 일치하는 경우 newStep을 사용한다. (새 트랙에 타겟팅중이므로)
bool usingNewStep = ctrl.m_newTrackIsOn && reverse == ctrl.m_newTrackWasReversed;
//Debug.Log(usingNewStep? "using newStep" : "using targetStep");
m_targetStep = usingNewStep? newStep : targetStep;
m_reverse = reverse;
m_newTrack = ctrl.m_newTrackIsOn? null : newtrack; // 새 트랙이 올라와있다면 newtrack은 무시한다.
m_trans = trans;
m_wasNaturalTransition = (targetStep % 2 == 1);
//Debug.Log(string.Format("[stepmove setup] targetStep : {0} reverse : {1} ... ctrl.m_newTrackIsOn : {2}", targetStep, reverse, ctrl.m_newTrackIsOn));
}
/// <summary>
/// 스테이트 - 트랜지션 완료
/// </summary>
private void ProcessState_TransitionFinish()
{
if (AudioSettings.dspTime >= lastCalculatedTransitionTime) // 트랜지션 시간이 되었다면 트랜지션 완전 마무리
{
m_state = State.PlayingOneSide;
m_transitionReserved = false;
if (m_tranScenario != null) // TransitionScenario 끝내기
{
bool revTrans = m_tranScenario.reverseTransition;
if (revTrans != m_reverse) // 특정 방향으로 진행하다가 다시 반대쪽으로 되돌아와서 트랜지션이 끝나는 경우, 트랜지션 비율을 원상복구해야한다.
{
revTrans = !revTrans;
}
transition = revTrans? 0 : 1;
m_tranScenario = null;
}
//Debug.Log("sideplayer stop");
sidePlayer.StopImmediately(); // 한쪽 플레이어 급히 정지
}
}
/// <summary>
/// 스테이트 - 트랜지션 완료
/// </summary>
private void ProcessState_TransitionFinish()
{
if (AudioSettings.dspTime >= lastCalculatedTransitionTime) // 트랜지션 시간이 되었다면 트랜지션 완전 마무리
{
m_state = State.PlayingOneSide;
m_transitionReserved = false;
if (m_tranScenario != null) // TransitionScenario 끝내기
{
bool revTrans = m_tranScenario.reverseTransition;
if (revTrans != m_reverse) // 특정 방향으로 진행하다가 다시 반대쪽으로 되돌아와서 트랜지션이 끝나는 경우, 트랜지션 비율을 원상복구해야한다.
revTrans = !revTrans;
transition = revTrans? 0 : 1;
m_tranScenario = null;
}
//Debug.Log("sideplayer stop");
sidePlayer.StopImmediately(); // 한쪽 플레이어 급히 정지
}
}
private bool ProcessMessage(ref Message msg)
{
bool consume;
switch(msg.type)
{
case Message.Type.ManualProgress:
{
if (m_state == State.TransitionReady || m_state == State.TransitionFinish) // 전환중인 경우엔 플래그가 꼬이지 않게 진행하지 않음 (m_transitionReserved)
{
consume = false;
break;
}
var trtime = currentPlayer.DoManualProgress();
consume = (trtime.transitionStart >= 0);
if (consume) // 정상적으로 처리된 경우에만 trtime을 트랜지션 시간으로 인정하여 보관한다.
{
lastCalculatedTransitionTime = trtime.transitionEnd;
//m_transitionType = SectionPlayer.TransitionType.Manual;
m_transitionReserved = true;
}
}
break;
case Message.Type.NaturalProgress:
{
if (m_state == State.TransitionReady || m_state == State.TransitionFinish) // 전환중인 경우엔 플래그가 꼬이지 않게 진행하지 않음 (m_transitionReserved)
{
consume = false;
break;
}
var trtime = currentPlayer.DoNaturalProgress();
consume = (trtime.transitionStart >= 0);
if (consume) // 정상적으로 처리된 경우에만 trtime을 트랜지션 시간으로 인정하여 보관한다.
{
lastCalculatedTransitionTime = trtime.transitionEnd;
//m_transitionType = SectionPlayer.TransitionType.Natural;
m_transitionReserved = true;
}
}
break;
case Message.Type.NewTrack:
if (!sidePlayer.isPlaying && !m_newTrackReady) // 반대쪽 플레이어가 현재 재생중이 아닌 경우만 세팅한다.
{
sidePlayer.SetTrack(msg.parameter as Data.Track, currentPlayer.clock);
m_newTrackReady = true;
consume = true;
// 해당 deck의 오토메이션 컨트롤 초기화
m_trackTransCtrls[(m_playerIdx + 1) % 2].Set(Data.Automation.TargetParam.Volume, 1);
m_trackTransCtrls[(m_playerIdx + 1) % 2].Set(Data.Automation.TargetParam.LowCut, 0);
}
else
{
consume = false;
}
break;
case Message.Type.NewTransitionScenario:
m_tranScenario = msg.parameter as Data.TransitionScenario;
consume = true;
break;
case Message.Type.BothTrack:
if (m_state != State.NotPlaying)
{
Debug.LogError("BothTrack message should be used only for initialization purpose.");
}
currentPlayer.SetTrack(msg.parameter as Data.Track);
sidePlayer.SetTrack(msg.parameter2 as Data.Track, currentPlayer.clock);
m_bothTrackReady = true;
m_newTrackReady = true;
consume = true;
break;
case Message.Type.StepTo:
{
if (m_state == State.TransitionReady || m_state == State.TransitionFinish) // 전환중인 경우엔 플래그가 꼬이지 않게 진행하지 않음 (m_transitionReserved)
{
consume = false;
break;
}
var step = (int)msg.parameter;
var reverse = (bool)msg.parameter2;
var trtime = currentPlayer.StepTo(step, reverse);
consume = (trtime.transitionStart >= 0);
if (consume)
{
lastCalculatedTransitionTime = trtime.transitionEnd;
//m_transitionType = SectionPlayer.TransitionType.Natural; // NOTE : 현재 이거 무의미해서 그냥 안고치고 이대로 둠....
m_transitionReserved = true;
m_reverse = reverse;
}
else
{
Debug.LogWarningFormat("cannot process StepTo - step : {0}, reverse : {1}, CalcStep : {2}", step, reverse, currentPlayer.CalcStep(reverse));
}
}
break;
case Message.Type.CancelNewTrack:
if (m_state == State.PlayingOneSide && !m_transitionReserved) // 트랜지션 예약이 되지 않았고, 한쪽 트랙 재생중인 시점에서는 m_newTrackReady를 꺼주면 됨
{
m_newTrackReady = false;
consume = true;
}
else if (m_state == State.OnTransition && !m_transitionReserved) // 트랜지션 예약이 되지 않았고, 현재 트랙 전환중일 경우, m_cancelOngoingTrackTransition을 켜주면 됨
{
m_cancelOngoingTrackTransition = true;
consume = true;
}
else
{
consume = false;
}
break;
case Message.Type.ForceOut:
currentPlayer.DoForceFadeout();
sidePlayer.DoForceFadeout();
m_state = State.ForceOut;
consume = true;
break;
default:
Debug.LogError("unknown message : " + msg.type);
consume = true;
break;
}
return consume;
}
public void Setup(int targetStep, int newStep, bool reverse, Data.Track newtrack = null, Data.TransitionScenario trans = null)
{
// 새 트랙이 진행중이면서 진행방향이 일치하는 경우 newStep을 사용한다. (새 트랙에 타겟팅중이므로)
bool usingNewStep = ctrl.m_newTrackIsOn && reverse == ctrl.m_newTrackWasReversed;
//Debug.Log(usingNewStep? "using newStep" : "using targetStep");
m_targetStep = usingNewStep? newStep : targetStep;
m_reverse = reverse;
m_newTrack = ctrl.m_newTrackIsOn? null : newtrack; // 새 트랙이 올라와있다면 newtrack은 무시한다.
m_trans = trans;
m_wasNaturalTransition = (targetStep % 2 == 1);
//Debug.Log(string.Format("[stepmove setup] targetStep : {0} reverse : {1} ... ctrl.m_newTrackIsOn : {2}", targetStep, reverse, ctrl.m_newTrackIsOn));
}
public void Setup(Data.Track curtrack, int curstep, Data.Track newtrack, int newstep, Data.TransitionScenario tscen)
{
m_curtrack = curtrack;
m_curstep = curstep;
m_newtrack = newtrack;
m_newstep = newstep;
m_tscen = tscen;
}
private bool ProcessMessage(ref Message msg)
{
bool consume;
switch (msg.type)
{
case Message.Type.ManualProgress:
{
if (m_state == State.TransitionReady || m_state == State.TransitionFinish) // 전환중인 경우엔 플래그가 꼬이지 않게 진행하지 않음 (m_transitionReserved)
{
consume = false;
break;
}
var trtime = currentPlayer.DoManualProgress();
consume = (trtime.transitionStart >= 0);
if (consume) // 정상적으로 처리된 경우에만 trtime을 트랜지션 시간으로 인정하여 보관한다.
{
lastCalculatedTransitionTime = trtime.transitionEnd;
//m_transitionType = SectionPlayer.TransitionType.Manual;
m_transitionReserved = true;
}
}
break;
case Message.Type.NaturalProgress:
{
if (m_state == State.TransitionReady || m_state == State.TransitionFinish) // 전환중인 경우엔 플래그가 꼬이지 않게 진행하지 않음 (m_transitionReserved)
{
consume = false;
break;
}
var trtime = currentPlayer.DoNaturalProgress();
consume = (trtime.transitionStart >= 0);
if (consume) // 정상적으로 처리된 경우에만 trtime을 트랜지션 시간으로 인정하여 보관한다.
{
lastCalculatedTransitionTime = trtime.transitionEnd;
//m_transitionType = SectionPlayer.TransitionType.Natural;
m_transitionReserved = true;
}
}
break;
case Message.Type.NewTrack:
if (!sidePlayer.isPlaying && !m_newTrackReady) // 반대쪽 플레이어가 현재 재생중이 아닌 경우만 세팅한다.
{
sidePlayer.SetTrack(msg.parameter as Data.Track, currentPlayer.clock);
m_newTrackReady = true;
consume = true;
// 해당 deck의 오토메이션 컨트롤 초기화
m_trackTransCtrls[(m_playerIdx + 1) % 2].Set(Data.Automation.TargetParam.Volume, 1);
m_trackTransCtrls[(m_playerIdx + 1) % 2].Set(Data.Automation.TargetParam.LowCut, 0);
}
else
{
consume = false;
}
break;
case Message.Type.NewTransitionScenario:
m_tranScenario = msg.parameter as Data.TransitionScenario;
consume = true;
break;
case Message.Type.BothTrack:
if (m_state != State.NotPlaying)
{
Debug.LogError("BothTrack message should be used only for initialization purpose.");
}
currentPlayer.SetTrack(msg.parameter as Data.Track);
sidePlayer.SetTrack(msg.parameter2 as Data.Track, currentPlayer.clock);
m_bothTrackReady = true;
m_newTrackReady = true;
consume = true;
break;
case Message.Type.StepTo:
{
if (m_state == State.TransitionReady || m_state == State.TransitionFinish) // 전환중인 경우엔 플래그가 꼬이지 않게 진행하지 않음 (m_transitionReserved)
{
consume = false;
break;
}
var step = (int)msg.parameter;
var reverse = (bool)msg.parameter2;
var trtime = currentPlayer.StepTo(step, reverse);
consume = (trtime.transitionStart >= 0);
if (consume)
{
lastCalculatedTransitionTime = trtime.transitionEnd;
//m_transitionType = SectionPlayer.TransitionType.Natural; // NOTE : 현재 이거 무의미해서 그냥 안고치고 이대로 둠....
m_transitionReserved = true;
m_reverse = reverse;
}
else
{
Debug.LogWarningFormat("cannot process StepTo - step : {0}, reverse : {1}, CalcStep : {2}", step, reverse, currentPlayer.CalcStep(reverse));
}
}
break;
case Message.Type.CancelNewTrack:
if (m_state == State.PlayingOneSide && !m_transitionReserved) // 트랜지션 예약이 되지 않았고, 한쪽 트랙 재생중인 시점에서는 m_newTrackReady를 꺼주면 됨
{
m_newTrackReady = false;
consume = true;
}
else if (m_state == State.OnTransition && !m_transitionReserved) // 트랜지션 예약이 되지 않았고, 현재 트랙 전환중일 경우, m_cancelOngoingTrackTransition을 켜주면 됨
{
m_cancelOngoingTrackTransition = true;
consume = true;
}
else
{
consume = false;
}
break;
case Message.Type.ForceOut:
currentPlayer.DoForceFadeout();
sidePlayer.DoForceFadeout();
m_state = State.ForceOut;
consume = true;
break;
default:
Debug.LogError("unknown message : " + msg.type);
consume = true;
break;
}
return(consume);
}
/// <summary>
/// 두 트랙 모두 설정 (초기화 목적)
/// </summary>
/// <param name="mainTrack"></param>
/// <param name="sideTrack"></param>
/// <param name="trans"></param>
public IMessageHandle[] SetBothTracks(Data.Track mainTrack, Data.Track sideTrack, Data.TransitionScenario trans)
{
return(new IMessageHandle[]
{
EnqueAndMakeHandle(new Message()
{
type = Message.Type.BothTrack, parameter = mainTrack, parameter2 = sideTrack
}),
EnqueAndMakeHandle(new Message()
{
type = Message.Type.NewTransitionScenario, parameter = trans
}),
});
}
void _StartWithTwoTrack(Data.Track mainTrack, int startStep, Data.Track sideTrack, int sideStep, Data.TransitionScenario transcen)
{
var newreq = new NewStartTwoTrackRequest(this);
newreq.Setup(mainTrack, startStep, sideTrack, sideStep, transcen);
m_reqQueue.Enqueue(newreq);
}
/// <summary>
/// 트랙 2개 재생 시작 (하나는 메인, 하나는 사이드)
/// </summary>
public void StartWithTwoTrack(Data.Track mainTrack, int startStep, Data.Track sideTrack, int sideStep, Data.TransitionScenario transcen)
{
m_cmdQueue.Enqueue(new Command()
{
type = Command.Type.StartWithTwoTrack, param1 = mainTrack, param2 = startStep, param3 = sideTrack, param4 = sideStep, param5 = transcen
});
}