godot md2 animated

extends MeshInstance




var nextFrame=0
var currentFrame=0
var animations=[]
export var faces=[]
export var NumFrames=0
export var animationVertex =[]
export var vertex_Count=0

var lastTime = 0
var lastanimation=0
var currentAnimation = 0

var rollto_anim = 0
var RollOver = false
var animlerp = 0

var animationEnd=false

var time_start = 0
var time_now = 0


#var mesh = null




func addAnimation(name, startFrame, endFrame, fps):
	animations.append([name, startFrame, endFrame, fps])

	return len(animations)

func numAnimations():
	return len(animations)

func BackAnimation():
	currentAnimation = (currentAnimation - 1) %  (numAnimations())
	if (currentAnimation < 0):
		 currentAnimation = numAnimations()
	setAnimation(currentAnimation);

func NextAnimation():
	currentAnimation = (currentAnimation +1) %  (numAnimations())
	if (currentAnimation >numAnimations()):
		 currentAnimation = 0
	setAnimation(currentAnimation)

func setAnimationNow(num):
	if (num == currentAnimation):
		return
	if num > len(animations):
		return


	currentAnimation = num
	currentFrame = animations[currentAnimation][1]
	lastanimation = currentAnimation

func setAnimation(num):
	if (num == currentAnimation):
		return
	if num > len(animations):
		return

	#if currentFrame<animations[currentAnimation][2]:
	#	return

	currentAnimation = num
	currentFrame = animations[currentAnimation][1]
	lastanimation = currentAnimation

func setAnimationByNameNow(name):
	for i in range(len(animations)):
		if (animations[i][0] == name):
			setAnimationNow(i)
			return
func setAnimationByName(name):
	for i in range(len(animations)):
		if (animations[i][0] == name):
			setAnimation(i)
			return
func getAnimationByName(name):
	for i in range(len(animations)):
		if (animations[i][0] == name):
			return	i

func SetAnimationRollOverByName(num ,next ):
	SetAnimationRollOver(getAnimationByName(num),getAnimationByName(next))

func SetAnimationRollOver(num ,next ):
	if (num == lastanimation):
		return
	if num > len(animations):
		return


	currentAnimation = num;
	currentFrame = animations[currentAnimation][1]
	lastanimation = currentAnimation
	RollOver = true
	rollto_anim = next



func Lerp(start , end , amount):
	var result = Vector3 ()
	result.x = start.x + ((end.x - start.x) * amount)
	result.y = start.y + ((end.y - start.y) * amount)
	result.z = start.z + ((end.z - start.z) * amount)
	return result


func animate(currentFrame,nextFrame,poll):
	var mdt = MeshDataTool.new()
	var err = mdt.create_from_surface(mesh, 0)
	if err != OK:
		print("Failure!")
		return
	var index=0
	for i in range(mdt.get_face_count()):
		var a = faces[i][0]
		var b = faces[i][1]
		var c = faces[i][2]
		var acurrent = animationVertex[currentFrame * vertex_Count + a]
		var bcurrent = animationVertex[currentFrame * vertex_Count + b]
		var ccurrent = animationVertex[currentFrame * vertex_Count + c]
		var anext = animationVertex[nextFrame * vertex_Count + a]
		var bnext = animationVertex[nextFrame * vertex_Count + b]
		var cnext = animationVertex[nextFrame * vertex_Count + c]
		var n = (bcurrent - ccurrent).cross(acurrent - bcurrent).normalized()

		mdt.set_vertex(index,Lerp(acurrent, anext, poll))
		mdt.set_vertex_normal(index, n + mdt.get_vertex_normal(index))
		index+=1

		mdt.set_vertex(index,Lerp(bcurrent, bnext, poll))
		mdt.set_vertex_normal(index, n + mdt.get_vertex_normal(index))
		index+=1

		mdt.set_vertex(index,Lerp(ccurrent, cnext, poll))
		mdt.set_vertex_normal(index, n + mdt.get_vertex_normal(index))
		index+=1




	mesh.surface_remove(0)
	mdt.commit_to_surface(mesh)

func getTimer():
	return OS.get_ticks_msec()/1000.0

func _ready():
	currentFrame=0
	nextFrame = 1
	addAnimation("all", 0, NumFrames-1, 15)


	time_start = 0

	currentFrame=0
	nextFrame=0

	setAnimation(0)

func get_Current_frame():
	return 	currentFrame

func _process(delta):

	var diff=1000.0
	time_now = OS.get_ticks_msec()
	var elapsedTime = time_now - time_start

	animlerp = elapsedTime / (diff / animations[currentAnimation][3])
	animationEnd=false


	#[name, startFrame, endFrame, fps])
	nextFrame = (currentFrame+1)
	if (nextFrame > animations[currentAnimation][2]):
		nextFrame = animations[currentAnimation][1]
		animationEnd=true


	if (RollOver):
		if (currentFrame >= animations[currentAnimation][2]):
			setAnimation(rollto_anim)
			RollOver = false


	#var timeEnd = (diff / animations[currentAnimation][3])
	if (elapsedTime >= (diff / animations[currentAnimation][3]) ):
		currentFrame = nextFrame
		time_start =  time_now


	#print(elapsedTime," ",time_start, " ",animlerp," ",timeEnd," -> ",currentFrame," ",nextFrame)

	animate(currentFrame,nextFrame,animlerp)