spine-runtimes/spine-lua/AnimationState.lua

-------------------------------------------------------------------------------
-- Spine Runtimes License Agreement
-- Last updated May 1, 2019. Replaces all prior versions.
--
-- Copyright (c) 2013-2019, Esoteric Software LLC
--
-- Integration of the Spine Runtimes into software or otherwise creating
-- derivative works of the Spine Runtimes is permitted under the terms and
-- conditions of Section 2 of the Spine Editor License Agreement:
-- http://esotericsoftware.com/spine-editor-license
--
-- Otherwise, it is permitted to integrate the Spine Runtimes into software
-- or otherwise create derivative works of the Spine Runtimes (collectively,
-- "Products"), provided that each user of the Products must obtain their own
-- Spine Editor license and redistribution of the Products in any form must
-- include this license and copyright notice.
--
-- THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY EXPRESS
-- OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-- OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
-- NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY DIRECT, INDIRECT,
-- INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-- BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, BUSINESS
-- INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND ON ANY
-- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-- EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-------------------------------------------------------------------------------

local setmetatable = setmetatable
local table_insert = table.insert
local utils = require "spine-lua.utils"
local Animation = require "spine-lua.Animation"
local MixBlend = Animation.MixBlend
local MixDirection = Animation.MixDirection
local AnimationStateData = require "spine-lua.AnimationStateData"
local math_min = math.min
local math_max = math.max
local math_abs = math.abs
local math_signum = utils.signum
local math_floor = math.floor
local math_ceil = math.ceil
local math_mod = utils.mod
local testBit = utils.testBit
local setBit = utils.setBit
local clearBit = utils.clearBit

local function zlen(array)
	return #array + 1
end

local EMPTY_ANIMATION = Animation.new("<empty>", {}, 0)
local SUBSEQUENT = 0
local FIRST = 1
local HOLD = 2
local HOLD_MIX = 3
local NOT_LAST = 4

local EventType = {
	start = 0,
	interrupt = 1,
	_end = 2,
	dispose = 3,
	complete = 4,
	event = 5
}

local EventQueue = {}
EventQueue.__index = EventQueue

function EventQueue.new (animationState)
	local self = {
		objects = {},
		animationState = animationState,
		drainDisabled = false
	}
	setmetatable(self, EventQueue)
	return self
end

function EventQueue:start (entry)
	local objects = self.objects
	table_insert(objects, EventType.start)
	table_insert(objects, entry)
	self.animationState.animationsChanged = true
end

function EventQueue:interrupt (entry)
	local objects = self.objects
	table_insert(objects, EventType.interrupt)
	table_insert(objects, entry)
end

function EventQueue:_end (entry)
	local objects = self.objects
	table_insert(objects, EventType._end)
	table_insert(objects, entry)
	self.animationState.animationsChanged = true
end

function EventQueue:dispose (entry)
	local objects = self.objects
	table_insert(objects, EventType.dispose)
	table_insert(objects, entry)
end

function EventQueue:complete (entry)
	local objects = self.objects
	table_insert(objects, EventType.complete)
	table_insert(objects, entry)
end

function EventQueue:event (entry, event)
	local objects = self.objects
	table_insert(objects, EventType.event)
	table_insert(objects, entry)
	table_insert(objects, event)
end

function EventQueue:drain ()
	if self.drainDisabled then return end -- Not reentrant.
	self.drainDisabled = true

	local objects = self.objects
	local as = self.animationState
	local i = 1
	local n = #objects
	while i <= n do
		local _type = objects[i]
		local entry = objects[i + 1]
		if _type == EventType.start then
			if entry.onStart then entry.onStart(entry) end
			if as.onStart then as.onStart(entry) end
		elseif _type == EventType.interrupt then
			if entry.onInterrupt then entry.onInterrupt(entry) end
			if as.onInterrupt then as.onInterrupt(entry) end
		elseif _type == EventType._end then
			if entry.onEnd then entry.onEnd(entry) end
			if as.onEnd then as.onEnd(entry) end
			-- fall through in ref impl
			if entry.onDispose then entry.onDispose(entry) end
			if as.onDispose then as.onDispose(entry) end
		elseif _type == EventType._dispose then
			if entry.onDispose then entry.onDispose(entry) end
			if as.onDispose then as.onDispose(entry) end
		elseif _type == EventType.complete then
			if entry.onComplete then entry.onComplete(entry) end
			if as.onComplete then as.onComplete(entry) end
		elseif _type == EventType.event then
			local event = objects[i + 2]
			if entry.onEvent then entry.onEvent(entry, event) end
			if as.onEvent then as.onEvent(entry, event) end
			i = i + 1
		end
		i = i + 2
	end
	self:clear()

	self.drainDisabled = false;
end

function EventQueue:clear ()
	self.objects = {}
end

local TrackEntry = {}
TrackEntry.__index = TrackEntry

function TrackEntry.new ()
	local self = {
		animation = nil,
		next = nil, mixingFrom = nil, mixingTo = nil,
		onStart = nil, onInterrupt = nil, onEnd = nil, onDispose = nil, onComplete = nil, onEvent = nil,
		trackIndex = 0,
		loop = false, holdPrevious = false,
		eventThreshold = 0, attachmentThreshold = 0, drawOrderThreshold = 0,
		animationStart = 0, animationEnd = 0, animationLast = 0, nextAnimationLast = 0,
		delay = 0, trackTime = 0, trackLast = 0, nextTrackLast = 0, trackEnd = 0, timeScale = 0,
		alpha = 0, mixTime = 0, mixDuration = 0, interruptAlpha = 0, totalAlpha = 0,
		mixBlend = MixBlend.replace,
		timelineMode = {},
		timelineHoldMix = {},
		timelinesRotation = {}
	}
	setmetatable(self, TrackEntry)
	return self
end

function TrackEntry:getAnimationTime ()
	if self.loop then
		local duration = self.animationEnd - self.animationStart
		if duration == 0 then return self.animationStart end
		return (self.trackTime % duration) + self.animationStart
	end
	return math_min(self.trackTime + self.animationStart, self.animationEnd)
end

function TrackEntry:resetRotationDirections ()
	self.timelinesRotation = {}
end

local AnimationState = {}
AnimationState.__index = AnimationState

function AnimationState.new (data)
	if not data then error("data cannot be nil", 2) end

	local self = {
		data = data,
		tracks = {},
		events = {},
		onStart = nil, onInterrupt = nil, onEnd = nil, onDispose = nil, onComplete = nil, onEvent = nil,
		queue = nil,
		propertyIDs = {},
		animationsChanged = false,
		timeScale = 1,
		mixingTo = {}
	}
	self.queue = EventQueue.new(self)
	setmetatable(self, AnimationState)
	return self
end

AnimationState.TrackEntry = TrackEntry

function AnimationState:update (delta)
	delta = delta * self.timeScale
	local tracks = self.tracks
	local queue = self.queue
	for i,current in pairs(tracks) do
		if current then
			current.animationLast = current.nextAnimationLast
			current.trackLast = current.nextTrackLast

			local currentDelta = delta * current.timeScale

			local skip = false
			if current.delay > 0 then
				current.delay = current.delay - currentDelta
				if current.delay <= 0 then
					skip = true
					currentDelta = -current.delay
					current.delay = 0
				end
			end

			if not skip then
				local _next = current.next
				if _next then
					-- When the next entry's delay is passed, change to the next entry, preserving leftover time.
					local nextTime = current.trackLast - _next.delay
					if nextTime >= 0 then
						_next.delay = 0
						if current.timeScale == 0 then
							_next.trackTime = 0
						else
							_next.trackTime = (nextTime / current.timeScale + delta) * _next.timeScale
						end
						current.trackTime = current.trackTime + currentDelta
						self:setCurrent(i, _next, true)
						while _next.mixingFrom do
							_next.mixTime = _next.mixTime + delta
							_next = _next.mixingFrom
						end
						skip = true
					end
				else
					-- Clear the track when there is no next entry, the track end time is reached, and there is no mixingFrom.
					if current.trackLast >= current.trackEnd and current.mixingFrom == nil then
						tracks[i] = nil
						queue:_end(current)
						self:disposeNext(current)
						skip = true
					end
				end

				if not skip then
					if current.mixingFrom and self:updateMixingFrom(current, delta) then
						-- End mixing from entries once all have completed.
						local from = current.mixingFrom
						current.mixingFrom = nil
						if from then from.mixingTo = nil end
						while from do
							queue:_end(from)
							from = from.mixingFrom
						end
					end

					current.trackTime = current.trackTime + currentDelta
				end
			end
		end
	end

	queue:drain()
end

function AnimationState:updateMixingFrom (to, delta)
	local from = to.mixingFrom
	if from == nil then return true end

	local finished = self:updateMixingFrom(from, delta)

	from.animationLast = from.nextAnimationLast
	from.trackLast = from.nextTrackLast

	-- Require mixTime > 0 to ensure the mixing from entry was applied at least once.
	if (to.mixTime > 0 and to.mixTime >= to.mixDuration) then
		-- Require totalAlpha == 0 to ensure mixing is complete, unless mixDuration == 0 (the transition is a single frame).
		if (from.totalAlpha == 0 or to.mixDuration == 0) then
			to.mixingFrom = from.mixingFrom
			if from.mixingFrom then from.mixingFrom.mixingTo = to end
			to.interruptAlpha = from.interruptAlpha
			self.queue:_end(from)
		end
		return finished
	end

	from.trackTime = from.trackTime + delta * from.timeScale
	to.mixTime = to.mixTime + delta
	return false;
end

function AnimationState:apply (skeleton)
	if skeleton == nil then error("skeleton cannot be null.", 2) end
	if self.animationsChanged then self:_animationsChanged() end

	local tracks = self.tracks
	local queue = self.queue
	local applied = false

	for i,current in pairs(tracks) do
		if not (current == nil or current.delay > 0) then
			applied = true

			local blend = current.mixBlend
			if i == 0 then blend = MixBlend.first end

			-- Apply mixing from entries first.
			local mix = current.alpha
			if current.mixingFrom then
				mix = mix * self:applyMixingFrom(current, skeleton, blend)
			elseif current.trackTime >= current.trackEnd and current.next == nil then
				mix = 0
			end

			-- Apply current entry.
			local animationLast = current.animationLast
			local animationTime = current:getAnimationTime()
			local timelines = current.animation.timelines
			if (i == 0 and mix == 1) or blend == MixBlend.add then
				for i,timeline in ipairs(timelines) do
					timeline:apply(skeleton, animationLast, animationTime, self.events, mix, blend, MixDirection._in)
				end
			else
				local timelineMode = current.timelineMode
				local firstFrame = #current.timelinesRotation == 0
				local timelinesRotation = current.timelinesRotation

				for ii,timeline in ipairs(timelines) do
					local timelineBlend = MixBlend.setup
					if clearBit(timelineMode[ii], NOT_LAST) == SUBSEQUENT then timelineBlend = blend end

					if timeline.type == Animation.TimelineType.rotate then
						self:applyRotateTimeline(timeline, skeleton, animationTime, mix, timelineBlend, timelinesRotation, ii * 2,
							firstFrame)
					else
						timeline:apply(skeleton, animationLast, animationTime, self.events, mix, timelineBlend, MixDirection._in)
					end
				end
			end
			self:queueEvents(current, animationTime)
			self.events = {};
			current.nextAnimationLast = animationTime
			current.nextTrackLast = current.trackTime
		end
	end

	queue:drain()
	return applied
end

function AnimationState:applyMixingFrom (to, skeleton, blend)
	local from = to.mixingFrom
	if from.mixingFrom then self:applyMixingFrom(from, skeleton, blend) end

	local mix = 0
	if to.mixDuration == 0 then -- Single frame mix to undo mixingFrom changes.
		mix = 1
		if blend == MixBlend.first then blend = MixBlend.setup end
	else
		mix = to.mixTime / to.mixDuration
		if mix > 1 then mix = 1 end
		if blend ~= MixBlend.first then blend = from.mixBlend end
	end

	local events = nil
	if mix < from.eventThreshold then events = self.events end
	local attachments = mix < from.attachmentThreshold
	local drawOrder = mix < from.drawOrderThreshold
	local animationLast = from.animationLast
	local animationTime = from:getAnimationTime()
	local timelines = from.animation.timelines
	local alphaHold = from.alpha * to.interruptAlpha
	local alphaMix = alphaHold * (1 - mix)

	if blend == MixBlend.add then
		for i,timeline in ipairs(timelines) do
			timeline:apply(skeleton, animationLast, animationTime, events, alphaMix, blend, MixDirection.out)
		end
	else
		local timelineMode = from.timelineMode
		local timelineHoldMix = from.timelineHoldMix

		local firstFrame = #from.timelinesRotation == 0
		local timelinesRotation = from.timelinesRotation

		from.totalAlpha = 0;

		for i,timeline in ipairs(timelines) do
			local skipSubsequent = false;
			local direction = MixDirection.out;
			local timelineBlend = MixBlend.setup
			local alpha = 0
			if clearBit(timelineMode[i], NOT_LAST) == SUBSEQUENT then
				timelineBlend = blend
				if not attachments and timeline.type == Animation.TimelineType.attachment then
					if testBit(timelineMode[i], NOT_LAST) then
						skipSubsequent = true
					else
						timelineBlend = MixBlend.setup
					end
				end
				if not drawOrder and timeline.type == Animation.TimelineType.drawOrder then skipSubsequent = true end
				alpha = alphaMix
			elseif clearBit(timelineMode[i], NOT_LAST) == FIRST then
				timelineBlend = MixBlend.setup
				alpha = alphaMix
			elseif clearBit(timelineMode[i], NOT_LAST) == HOLD then
				timelineBlend = MixBlend.setup
				alpha = alphaHold
			else
				timelineBlend = MixBlend.setup
				local holdMix = timelineHoldMix[i]
				alpha = alphaHold * math_max(0, 1 - holdMix.mixtime / holdMix.mixDuration)
			end

			if not skipSubsequent then
				from.totalAlpha = from.totalAlpha + alpha
				if timeline.type == Animation.TimelineType.rotate then
					self:applyRotateTimeline(timeline, skeleton, animationTime, alpha, timelineBlend, timelinesRotation, i * 2, firstFrame)
				else
					if timelineBlend == MixBlend.setup then
						if timeline.type == Animation.TimelineType.attachment then
							if attachments or testBit(timelineMode[i], NOT_LAST) then direction = MixDirection._in end
						elseif timeline.type == Animation.TimelineType.drawOrder then
							if drawOrder then direction = MixDirection._in end
						end
					end
					timeline:apply(skeleton, animationLast, animationTime, self.events, alpha, timelineBlend, direction)
				end
			end
		end
	end

	if (to.mixDuration > 0) then
		self:queueEvents(from, animationTime)
	end
	self.events = {};
	from.nextAnimationLast = animationTime
	from.nextTrackLast = from.trackTime

	return mix
end

function AnimationState:applyRotateTimeline (timeline, skeleton, time, alpha, blend, timelinesRotation, i, firstFrame)
	if firstFrame then
		timelinesRotation[i] = 0
		timelinesRotation[i+1] = 0
	end

	if alpha == 1 then
		timeline:apply(skeleton, 0, time, nil, 1, blend, MixDirection._in)
		return
	end

	local rotateTimeline = timeline
	local frames = rotateTimeline.frames
	local bone = skeleton.bones[rotateTimeline.boneIndex]
	if not bone.active then return end
	local r1 = 0
	local r2 = 0
	if time < frames[0] then
		if blend == MixBlend.setup then
			bone.rotation = bone.data.rotation
			return
		elseif blend == MixBlend.first then
			r1 = bone.rotation
			r2 = bone.data.rotation
		else
			return
		end
	else
		if blend == MixBlend.setup then
			r1 = bone.data.rotation
		else
			r1 = bone.rotation
		end
		if time >= frames[zlen(frames) - Animation.RotateTimeline.ENTRIES] then -- Time is after last frame.
			r2 = bone.data.rotation + frames[zlen(frames) + Animation.RotateTimeline.PREV_ROTATION]
		else
			-- Interpolate between the previous frame and the current frame.
			local frame = Animation.binarySearch(frames, time, Animation.RotateTimeline.ENTRIES)
			local prevRotation = frames[frame + Animation.RotateTimeline.PREV_ROTATION]
			local frameTime = frames[frame]
			local percent = rotateTimeline:getCurvePercent(math_floor(frame / 2) - 1,
				1 - (time - frameTime) / (frames[frame + Animation.RotateTimeline.PREV_TIME] - frameTime))

			r2 = frames[frame + Animation.RotateTimeline.ROTATION] - prevRotation
			r2 = r2 - (16384 - math_floor(16384.499999999996 - r2 / 360)) * 360
			r2 = prevRotation + r2 * percent + bone.data.rotation
			r2 = r2 - (16384 - math_floor(16384.499999999996 - r2 / 360)) * 360
		end
	end

	-- Mix between rotations using the direction of the shortest route on the first frame while detecting crosses.
	local total = 0
	local diff = r2 - r1
	diff = diff - (16384 - math_floor(16384.499999999996 - diff / 360)) * 360
	if diff == 0 then
		total = timelinesRotation[i]
	else
		local lastTotal = 0
		local lastDiff = 0
		if firstFrame then
			lastTotal = 0
			lastDiff = diff
		else
			lastTotal = timelinesRotation[i] -- Angle and direction of mix, including loops.
			lastDiff = timelinesRotation[i + 1] -- Difference between bones.
		end
		local current = diff > 0
		local dir = lastTotal >= 0
		-- Detect cross at 0 (not 180).
		if math_signum(lastDiff) ~= math_signum(diff) and math_abs(lastDiff) <= 90 then
			-- A cross after a 360 rotation is a loop.
			if math_abs(lastTotal) > 180 then lastTotal = lastTotal + 360 * math_signum(lastTotal) end
			dir = current
		end
		total = diff + lastTotal - math_mod(lastTotal, 360) -- FIXME used to be %360, store loops as part of lastTotal.
		if dir ~= current then total = total + 360 * math_signum(lastTotal) end
		timelinesRotation[i] = total
	end
	timelinesRotation[i + 1] = diff
	r1 = r1 + total * alpha
	bone.rotation = r1 - (16384 - math_floor(16384.499999999996 - r1 / 360)) * 360
end

function AnimationState:queueEvents (entry, animationTime)
	local animationStart = entry.animationStart
	local animationEnd = entry.animationEnd
	local duration = animationEnd - animationStart
	local trackLastWrapped = entry.trackLast % duration

	-- Queue events before complete.
	local events = self.events
	local queue = self.queue
	local i = 1
	local n = #events
	while i <= n do
		local event = events[i]
		if event.time < trackLastWrapped then break end
		if not (event.time > animationEnd) then -- Discard events outside animation start/end.
			queue:event(entry, event)
		end
		i = i + 1
	end

	-- Queue complete if completed a loop iteration or the animation.
	local queueComplete = false
	if entry.loop then
		queueComplete = duration == 0 or (trackLastWrapped > entry.trackTime % duration)
	else
		queueComplete = (animationTime >= animationEnd and entry.animationLast < animationEnd)
	end
	if queueComplete then
		queue:complete(entry)
	end

	-- Queue events after complete.
	while i <= n do
		local event = events[i]
		if not (event.time < animationStart) then --// Discard events outside animation start/end.
			queue:event(entry, event)
		end
		i = i + 1
	end
end

function AnimationState:clearTracks ()
	local queue = self.queue
	local tracks = self.tracks
	local oldDrainDisabled = queue.drainDisabled
	queue.drainDisabled = true;
	for i,track in pairs(tracks) do
		self:clearTrack(i)
	end
	tracks = {}
	queue.drainDisabled = oldDrainDisabled
	queue:drain();
end

function AnimationState:clearTrack (trackIndex)
	local tracks = self.tracks
	local queue = self.queue
	local current = tracks[trackIndex]
	if current == nil then return end

	queue:_end(current)

	self:disposeNext(current)

	local entry = current;
	while (true) do
		local from = entry.mixingFrom
		if from == nil then break end
		queue:_end(from)
		entry.mixingFrom = nil
		entry.mixingTo = nil
		entry = from
	end

	tracks[current.trackIndex] = nil

	queue:drain()
end

function AnimationState:setCurrent (index, current, interrupt)
	local from = self:expandToIndex(index)
	local tracks = self.tracks
	local queue = self.queue
	tracks[index] = current

	if from then
		if interrupt then queue:interrupt(from) end
		current.mixingFrom = from
		from.mixingTo = current
		current.mixTime = 0

		if from.mixingFrom and from.mixDuration > 0 then
			current.interruptAlpha = current.interruptAlpha * math_min(1, from.mixTime / from.mixDuration)
		end

		from.timelinesRotation = {};
	end

	queue:start(current)
end

function AnimationState:setAnimationByName (trackIndex, animationName, loop)
		local animation = self.data.skeletonData:findAnimation(animationName)
		if not animation then error("Animation not found: " .. animationName, 2) end
		return self:setAnimation(trackIndex, animation, loop)
end

function AnimationState:setAnimation (trackIndex, animation, loop)
	if not animation then error("animation cannot be null.") end
	local interrupt = true;
	local current = self:expandToIndex(trackIndex)
	local queue = self.queue
	local tracks = self.tracks
	if current then
		if current.nextTrackLast == -1 then
			-- Don't mix from an entry that was never applied.
			tracks[trackIndex] = current.mixingFrom
			queue:interrupt(current)
			queue:_end(current)
			self:disposeNext(current)
			current = current.mixingFrom
			interrupt = false;
		else
			self:disposeNext(current)
		end
	end
	local entry = self:trackEntry(trackIndex, animation, loop, current)
	self:setCurrent(trackIndex, entry, interrupt)
	queue:drain()
	return entry
end

function AnimationState:addAnimationByName (trackIndex, animationName, loop, delay)
	local animation = self.data.skeletonData:findAnimation(animationName)
	if not animation then error("Animation not found: " + animationName) end
	return self:addAnimation(trackIndex, animation, loop, delay)
end

function AnimationState:addAnimation (trackIndex, animation, loop, delay)
	if not animation then error("animation cannot be null.") end

	local last = self:expandToIndex(trackIndex)
	if last then
		while last.next do
			last = last.next
		end
	end

	local entry = self:trackEntry(trackIndex, animation, loop, last)
	local queue = self.queue
	local data = self.data

	if not last then
		self:setCurrent(trackIndex, entry, true)
		queue:drain()
	else
		last.next = entry
		if delay <= 0 then
			local duration = last.animationEnd - last.animationStart
			if duration ~= 0 then
				if last.loop then
					delay = delay + duration * (1 + math_floor(last.trackTime / duration))
				else
					delay = delay + math_max(duration, last.trackTime)
				end
				delay = delay - data:getMix(last.animation, animation)
			else
				delay = last.trackTime
			end
		end
	end

	entry.delay = delay
	return entry
end

function AnimationState:setEmptyAnimation (trackIndex, mixDuration)
	local entry = self:setAnimation(trackIndex, EMPTY_ANIMATION, false)
	entry.mixDuration = mixDuration
	entry.trackEnd = mixDuration
	return entry
end

function AnimationState:addEmptyAnimation (trackIndex, mixDuration, delay)
	if delay <= 0 then delay = delay - mixDuration end
	local entry = self:addAnimation(trackIndex, EMPTY_ANIMATION, false, delay)
	entry.mixDuration = mixDuration
	entry.trackEnd = mixDuration
	return entry
end

function AnimationState:setEmptyAnimations (mixDuration)
	local queue = self.queue
	local oldDrainDisabled = queue.drainDisabled
	queue.drainDisabled = true
	for i,current in pairs(self.tracks) do
		if current then self:setEmptyAnimation(current.trackIndex, mixDuration) end
	end
	queue.drainDisabled = oldDrainDisabled
	queue:drain()
end

function AnimationState:expandToIndex (index)
	return self.tracks[index]
end

function AnimationState:trackEntry (trackIndex, animation, loop, last)
	local data = self.data
	local entry = TrackEntry.new()
	entry.trackIndex = trackIndex
	entry.animation = animation
	entry.loop = loop
	entry.holdPrevious = false

	entry.eventThreshold = 0
	entry.attachmentThreshold = 0
	entry.drawOrderThreshold = 0

	entry.animationStart = 0
	entry.animationEnd = animation.duration
	entry.animationLast = -1
	entry.nextAnimationLast = -1

	entry.delay = 0
	entry.trackTime = 0
	entry.trackLast = -1
	entry.nextTrackLast = -1
	entry.trackEnd = 999999999
	entry.timeScale = 1

	entry.alpha = 1
	entry.interruptAlpha = 1
	entry.mixTime = 0
	if not last then
		entry.mixDuration = 0
	else
		entry.mixDuration = data:getMix(last.animation, animation)
	end
	entry.mixBlend = MixBlend.replace
	return entry
end

function AnimationState:disposeNext (entry)
	local _next = entry.next
	local queue = self.queue
	while _next do
		queue:dispose(_next)
		_next = _next.next
	end
	entry.next = nil
end

function AnimationState:_animationsChanged ()
	self.animationsChanged = false

	self.propertyIDs = {}

	local highestIndex = -1
	for i, entry in pairs(self.tracks) do
		if i > highestIndex then highestIndex = i end

		if entry then
			while entry.mixingFrom do
				entry = entry.mixingFrom
			end

			repeat
				if (entry.mixingTo == nil or entry.mixBlend ~= MixBlend.add) then
					self:computeHold(entry)
				end
				entry = entry.mixingTo
			until (entry == nil)
		end
	end

	self.propertyIDs = {}
	for i = highestIndex, 0, -1 do
		entry = self.tracks[i]
		while entry do
			self:computeNotLast(entry)
			entry = entry.mixingFrom
		end
	end
end

function AnimationState:computeNotLast(entry)
	local timelines = entry.animation.timelines
	local timelinesCount = #entry.animation.timelines
	local timelineMode = entry.timelineMode
	local propertyIDs = self.propertyIDs

	local i = 1
	while i <= timelinesCount do
		local timeline = timelines[i]
		if (timeline.type == Animation.TimelineType.attachment) then
			local slotIndex = timeline.slotIndex
			if not (propertyIDs[slotIndex] == nil) then
				timelineMode[i] = setBit(timelineMode[i], NOT_LAST)
			else
				propertyIDs[slotIndex] = true
			end
		end
		i = i + 1
	end
end

function AnimationState:computeHold(entry)
	local to = entry.mixingTo
	local timelines = entry.animation.timelines
	local timelinesCount = #entry.animation.timelines
	local timelineMode = entry.timelineMode
	local timelineHoldMix = entry.timelineHoldMix
	local propertyIDs = self.propertyIDs

	if (to and to.holdPrevious) then
		local i = 1
		while i <= timelinesCount do
			local id = "" .. timelines[i]:getPropertyId()
			if propertyIDs[id] == nil then
				propertyIDs[id] = id
			end
			timelineMode[i] = HOLD
		end
		return
	end

	local i = 1
	local skip
	while i <= timelinesCount do
		local id = "" .. timelines[i]:getPropertyId()
		if propertyIDs[id] then
			timelineMode[i] = SUBSEQUENT
		else
			propertyIDs[id] = id
			local timeline = timelines[i]
			if to == nil or timeline.type == Animation.TimelineType.attachment
				or timeline.type == Animation.TimelineType.drawOrder
				or timeline.type == Animation.TimelineType.event
				or not self:hasTimeline(to, id) then
				timelineMode[i] = FIRST
			else
				local next = to.mixingTo
				skip = false
				while next do
					if not self:hasTimeline(id) then
						if entry.mixDuration > 0 then
							timelineMode[i] = HOLD_MIX
							timelineHoldMix[i] = next
							skip = true
							break
						end
					end
					next = next.mixingTo
				end
				if not skip then 	timelineMode[i] = HOLD end
			end
		end
		i = i + 1
	end
end

function AnimationState:hasTimeline(entry, id)
	local timelines = entry.animation.timelines
	for i,timeline in ipairs(timelines) do
		if timeline:getPropertyId() == id then return true end
	end
	return false
end

function AnimationState:getCurrent (trackIndex)
	return self.tracks[trackIndex]
end

function AnimationState:clearListeners ()
	self.onStart = nil
	self.onInterrupt = nil
	self.onEnd = nil
	self.onComplete = nil
	self.onDispose = nil
	self.onEvent = nil
end

function AnimationState:clearListenerNotificatin ()
	self.queue:clear()
end

return AnimationState