
--Valueを整数にする関数切り下げ
function integer(Value)
 local v=Value-Value%1
 return v
end

--aをb倍にする関数
function bai(a,b)
 local v=(math.floor(a/b))*b
 return v
end

--valueの上限と下限をカットする関数
function cut(Value,Min,Max)
 local v
 if(Value>Max)then
  v=Max
 elseif(Value<Min)then
  v=Min
 else
  v=Value
 end
 return v
end

--valueが偶数だったら1返す関数
function Even(Value)
 if(Value%2==0)then
   return 1
 else
   return 0
 end
end


--x軸周り回転関数
local function Rot_x(x,y,z,angle)
 local x2,y2,z2
 x2=x
 y2=y*math.cos(angle)-z*math.sin(angle)
 z2=y*math.sin(angle)+z*math.cos(angle)
 return x2,y2,z2
end
--y軸周り回転関数
local function Rot_y(x,y,z,angle)
 local x2,y2,z2
 x2=x*math.cos(angle)+z*math.sin(angle)
 y2=y
 z2=-x*math.sin(angle)+z*math.cos(angle)
 return x2,y2,z2
end
--z軸周り回転関数
local function Rot_z(x,y,z,angle)
 local x2,y2,z2
 x2=x*math.cos(angle)-y*math.sin(angle)
 y2=x*math.sin(angle)+y*math.cos(angle)
 z2=z
 return x2,y2,z2
end
--[[
--方向ベクトルに向く関数
local function turn_vec(kx,ky,kz)
 local rx,ry,rz=0,0,0
 local K=math.sqrt(kx^2+ky^2+kz^2)
 kx=kx/K
 ky=ky/K
 kz=kz/K
 local d=math.sqrt(kx^2+ky^2)
 rx=math.acos(kz/d)
 ry=math.acos(d)
-- rz=math.atan2(ky,kx)
 return rx,ry,rz
end
]]--
--方向ベクトルに向く関数(大体)
local function turn_vec(kx,ky,kz)
 local rx,ry,rz=0,0,0
 local K=math.sqrt(kx^2+ky^2+kz^2)
 kx=kx/K
 ky=ky/K
 kz=kz/K
 local d=math.sqrt(kx^2+kz^2)
 if(kx>0)then
  ry=math.acos(kz/d)
 else
  ry=-math.acos(kz/d)
 end
 if(kz*ky<0)then
  rx=math.acos(d)
 else
  rx=-math.acos(d)
 end
-- rz=math.atan2(ky,kx)
 return rx,ry,rz
end

--二つのベクトルから回転角を求める
function two_vec_to_ang(x1,y1,z1,x2,y2,z2)
 local sita1=math.atan2(y2-y1,x2-x1)
 local sita2=math.atan2(z2-z1,y2-y1)
 local sita3=math.atan2(x2-x1,z2-z1)
 return sita1,sita2,sita3
end

--valueの上限と下限をカットする関数
function cut(Value,Min,Max)
 local v
 if(Value>Max)then
  v=Max
 elseif(Value<Min)then
  v=Min
 else
  v=Value
 end
 return v
end


--二つのベクトルの角度を求める関数
function two_vec_ang(x,y,z,x2,y2,z2)
 local ang=math.acos((x*x2+y*y2+z*z2)/(math.sqrt(x^2+y^2+z^2)*math.sqrt(x2^2+y2^2+z2^2)))
 return ang
end

--二つのベクトルがなす平面の法線ベクトル
function two_vec_nvec(x,y,z,x2,y2,z2,flag)
 local x3,y3,z3=y*z2-y2*z,z*x2-z2*x,x*y2-x2*y
 if(flag==1)then
  local D=math.sqrt(x3^2+y3^2+z3^2)
  x3=x3/D
  y3=y3/D
  z3=z3/D
 end
 return x3,y3,z3
end

--Kベクトルまわり回転関数
local function Rot_k(x,y,z,kx,ky,kz,angle)
 local x2,y2,z2
 local K=math.sqrt(kx^2+ky^2+kz^2)
 kx=kx/K
 ky=ky/K
 kz=kz/K
 x2=(kx^2*(1-math.cos(angle))+math.cos(angle))*x+(kx*ky*(1-math.cos(angle))-kz*math.sin(angle))*y+(kz*kx*(1-math.cos(angle))+ky*math.sin(angle))*z
 y2=(kx*ky*(1-math.cos(angle))+kz*math.sin(angle))*x+(ky^2*(1-math.cos(angle))+math.cos(angle))*y+(ky*kz*(1-math.cos(angle))-kx*math.sin(angle))*z
 z2=(kz*kx*(1-math.cos(angle))-kz*math.sin(angle))*x+(ky*kz*(1-math.cos(angle))+kx*math.sin(angle))*y+(kz^2*(1-math.cos(angle))+math.cos(angle))*z
 return x2,y2,z2
end

--オイラーパラメータを返す関数
function euler_par(kx,ky,kz,sita)
 local e1,e2,e3,e0
 local K=math.sqrt(kx^2+ky^2+kz^2)
 kx=kx/K
 ky=ky/K
 kz=kz/K
 e0=math.cos(sita/2)
 e1=kx*math.sin(sita/2)
 e2=ky*math.sin(sita/2)
 e3=kz*math.sin(sita/2)
 return e0,e1,e2,e3
end

--オイラーパラメータから回転行列にして回転
function euler_Rot(x,y,z,e0,e1,e2,e3)
 local x2,y2,z2=0,0,0
 x2=(e0^2+e1^2-e2^2-e3^2)*x+(2*(e1*e2+e0*e3))*y+(2*(e1*e3-e0*e2))*z
 y2=(2*(e1*e2-e0*e3))*x+(e0^2-e1^2+e2^2-e3^2)*y+(2*(e2*e3+e0*e1))*z
 z2=(2*(e1*e3+e0*e2))*x+(2*(e2*e3-e0*e1))*y+(e0^2-e1^2-e2^2+e3^2)*z
 return x2,y2,z2
end

function quata_Rot(x,y,z,kx,ky,kz,sita)
 local e0,e1,e2,e3=euler_par(kx,ky,kz,sita)
 local x2,y2,z2=euler_Rot(x,y,z,e0,e1,e2,e3)
 return x2,y2,z2
end

function return_jiku(x,y,z,x1,y1,z1)

 local Xkx,Xky,Xkz=two_vec_nvec(x,y,z,x1,y1,z1)
 local Ykx,Yky,Ykz=two_vec_nvec(Xkx,Xky,Xkz,x,y,z)
 local Zkx,Zky,Zkz=two_vec_nvec(Ykx,Yky,Ykz,Xkx,Xky,Xkz)

 return Xkx,Xky,Xkz,Ykx,Yky,Ykz,Zkx,Zky,Zkz

end

--draw
function turn_draw(obj,x,y,z,zoom,alp,RX,RY,RZ,kx,ky,kz,SIN)
 
 nx,ny,nz=two_vec_nvec(0,0,-1,kx,ky,kz,1)
 nx2,ny2,nz2=two_vec_nvec(kx,ky,kz,nx,ny,nz,1)
--local nx2,ny2,nz2=10,10,10
local ang=two_vec_ang(0,0,-1,kx,ky,kz)

local size=obj.w/2

local p1x,p1y,p1z=size*(kx-nx2),size*(ky-ny2),size*(kz-nz2)
local p2x,p2y,p2z=size*(-kx-nx2),size*(-ky-ny2),size*(-kz-nz2)
local p3x,p3y,p3z=size*(-kx+nx2),size*(-ky+ny2),size*(-kz+nz2)
local p4x,p4y,p4z=size*(kx+nx2),size*(ky+ny2),size*(kz+nz2)

--[[
RX,RY,RZ=math.rad(RX),math.rad(RY),math.rad(RZ)

p1x,p1y,p1z=quata_Rot(p1x,p1y,p1z,nx,ny,nz,-ang+RY)
p2x,p2y,p2z=quata_Rot(p2x,p2y,p2z,nx,ny,nz,-ang+RY)
p3x,p3y,p3z=quata_Rot(p3x,p3y,p3z,nx,ny,nz,-ang+RY)
p4x,p4y,p4z=quata_Rot(p4x,p4y,p4z,nx,ny,nz,-ang+RY)

kx,ky,kz=quata_Rot(kx,ky,kz,nx,ny,nz,-ang)
nx,ny,nz=quata_Rot(nx,ny,nz,nx,ny,nz,-ang)
local rxx,rxy,rxz=quata_Rot(1,0,0,nx,ny,nz,-ang)
local ryx,ryy,ryz=quata_Rot(0,1,0,nx,ny,nz,-ang)
local rzx,rzy,rzz=quata_Rot(0,0,1,nx,ny,nz,-ang)

p1x,p1y,p1z=quata_Rot(p1x,p1y,p1z,rxx,rxy,rxz,RX)
p2x,p2y,p2z=quata_Rot(p2x,p2y,p2z,rxx,rxy,rxz,RX)
p3x,p3y,p3z=quata_Rot(p3x,p3y,p3z,rxx,rxy,rxz,RX)
p4x,p4y,p4z=quata_Rot(p4x,p4y,p4z,rxx,rxy,rxz,RX)

ryx,ryy,ryz=quata_Rot(ryx,ryy,ryz,rxx,rxy,rxz,RX)
rzx,rzy,rzz=quata_Rot(rzx,rzy,rzz,rxx,rxy,rxz,RX)

p1x,p1y,p1z=quata_Rot(p1x,p1y,p1z,ryx,ryy,ryz,RY)
p2x,p2y,p2z=quata_Rot(p2x,p2y,p2z,ryx,ryy,ryz,RY)
p3x,p3y,p3z=quata_Rot(p3x,p3y,p3z,ryx,ryy,ryz,RY)
p4x,p4y,p4z=quata_Rot(p4x,p4y,p4z,ryx,ryy,ryz,RY)

rzx,rzy,rzz=quata_Rot(rzx,rzy,rzz,ryx,ryy,ryz,RY)

p1x,p1y,p1z=quata_Rot(p1x,p1y,p1z,rzx,rzy,rzz,RZ)
p2x,p2y,p2z=quata_Rot(p2x,p2y,p2z,rzx,rzy,rzz,RZ)
p3x,p3y,p3z=quata_Rot(p3x,p3y,p3z,rzx,rzy,rzz,RZ)
p4x,p4y,p4z=quata_Rot(p4x,p4y,p4z,rzx,rzy,rzz,RZ)
]]--

--local Xkx,Xky,Xkz,Ykx,Yky,Ykz,Zkx,Zky,Zkz=return_jiku(kx,ky,kz,0,0,1)

--local Xkx,Xky,Xkz=1,0,0
--local Ykx,Yky,Ykz=0,1,0
--local Zkx,Zky,Zkz=0,0,1


obj.drawpoly(
x+zoom*p1x,y+zoom*p1y,z+zoom*p1z,
x+zoom*p2x,y+zoom*p2y,z+zoom*p2z,
x+zoom*p3x,y+zoom*p3y,z+zoom*p3z,
x+zoom*p4x,y+zoom*p4y,z+zoom*p4z,
0,0, obj.w,0, obj.w,obj.h, 0,obj.h,
alp)

end
