#2011.5.5

require "opengl"
require "glut"
require "matrix"

class Matrix
  def []=(i,j,x)
    @rows[i][j]=x
  end
end #class
class Vector
  def outer_product(u)
  Vector[
      self[1] * u[2] - self[2] * u[1],
      self[2] * u[0] - self[0] * u[2],
      self[0] * u[1] - self[1] * u[0],
  ]
  end
end

class Rubic # with tetragonal shape
Face=20
Color=[
[0,0,0.6],[0,0,1],
[1,0,0],[1,0,1],
[0,1,0],[0,1,1],
[1,1,0],[1,1,1],
[0,0.7,0],[0,0.7,1],
[1,0.7,0],[1,0.7,1],
[0.5,0,0],[0.5,0,1],
#[0.5,1,0],[0.5,1,1],
[0.5,0.7,0],[0.5,0.7,1],
[0.5,0.7,0.6],[0,1,0.6],
[1,1,0.6],[1,0.7,0.6],
]
#1 0.7 0
Fa,Fb=2.0*0.25,(1.0+Math::sqrt(5))*0.25
Vertex=[
  [Fb,Fa,0],[0,Fb,Fa],[Fa,0,Fb],
  [Fb,-Fa,0],[0,Fb,-Fa],[-Fa,0,Fb],
  [-Fb,-Fa,0],[0,-Fb,-Fa],[-Fa,0,-Fb],
  [-Fb,Fa,0],[0,-Fb,Fa],[Fa,0,-Fb],
  ]
Faces=[
  [ 0, 3, 2],[ 6, 8, 9],
  [ 0,11, 3],[ 6, 9, 5],
  [ 1, 4, 0],[ 6,10, 7],
  [ 1, 9, 4],[ 7,10, 3],
  [ 2, 5, 1],[ 7,11, 8],
  [ 2,10, 5],[ 8,11, 4],
  [0,2,1],[6,7,8],
  [9,1,5],[3,11,7],
  [3,10,2],[4,9,8],
  [0,4,11],[6,5,10],
]

def initialize(div=3)
  @div=div
  @face=[]
  Face.times{|i|
    face=[]
    div.times{ face<<Array::new(div,i) }
    @face<<face
  }
end
attr_accessor :face
attr_reader :div
def unit(f,x,y) # corner of the face
  org,xv,yv=Faces[f].map{|i| Vector[*Vertex[i]]}
  xv-=org
  yv-=org
  ((x+y<@div)? [[x+0.01,y+0.01],[x+0.98,y+0.01],[x+0.01,y+0.98]] :
    [[@div-x-0.01,@div-y-0.01],[@div-x-0.98,@div-y-0.01],[@div-x-0.01,@div-y-0.98]]).map{|xx,yy|
      (org+xv*(xx.to_f/@div)+yv*(yy.to_f/@div)).to_a }
end
def center(f,x,y) # corner of the face
  unit(f,x+1.0/3,y+1.0/3)[0]
end
def rotate(k,d=0) # axis and division No.
  f=k
  f=Face-1-k if d==0 # opposite face
if d==0 or d==@div-1 #the top face
  fa=[
    [[3,1,13,5,19, 0,0,0,0,0], [0,12,4,18,2, 0,0,1,0,0]],
    [[7,5,13,9,15, 0,1,2,0,1], [6,4,12,8,14, 0,0,1,1,2]],
    [[11,9,13,1,17, 0,1,1,2,1], [8,12,0,16,10, 0,2,1,1,0]],
    [[14,6,17,1,3, 0,2,2,1,2], [16,0,2,15,7, 0,2,1,0,1]],
    [[10,19,5,7,16, 2,1,2,2,2], [17,11,18,4,6, 0,1,2,2,1]],
    [[2,15,9,11,18, 2,2,2,2,1], [3,14,8,10,19, 1,1,2,1,2]],
  ][k][(d==0)?0:1]
  f0,f1,f2,f3,f4,k0,k1,k2,k3,k4=fa
  @div.times{|i|
  @div.times{|j|
ii=[i,j,@div-1-i-j]
jj=[j,@div-1-i-j,i]
  i0,i1,i2,i3,i4=ii[k0],ii[k1],ii[k2],ii[k3],ii[k4]
  j0,j1,j2,j3,j4=jj[k0],jj[k1],jj[k2],jj[k3],jj[k4]
  @face[f0][i0][j0],@face[f1][i1][j1],@face[f2][i2][j2],@face[f3][i3][j3],@face[f4][i4][j4]=
  @face[f1][i1][j1],@face[f2][i2][j2],@face[f3][i3][j3],@face[f4][i4][j4],@face[f0][i0][j0]
  }}
#  @div.times{|j|
#    if i+j<@div
#      @face[f][j][@div-1-i-j]=f0[i,j] 
#    else
#      @face[f][j][2*@div-1-i-j]=f0[i,j]
#    end
#  }}
end
#side faces
  fa=[ # face arrangement
    [[11,15,16,8,6, 0,1,2,2,2], [10,14,17,9,7, 0,2,0,2,1]], 
    [[3,17,18,0,10, 0,1,1,2,2], [2,16,19,1,11, 0,1,2,1,1]],
    [[7,19,14,4,2, 0,0,0,2,2], [6,18,15,5,3, 0,0,0,2,1]],
    [[5,10,12,18,9, 0,1,1,2,1], [4,11,13,19,8, 1,2,2,1,0]],
    [[9,2,12,14,1, 0,1,2,1,0], [8,3,13,15,0, 1,2,1,2,0]],
    [[12,16,5,1,6, 0,0,1,2,1], [13,17,4,0,7, 0,2,0,1,2]],
  ][k]
  fa.each{|f0,f1,f2,f3,f4,k0,k1,k2,k3,k4|
  @div.times{|i|
  @div.times{|j|
if i+j==d
ii=[i,j,@div-1-d]
jj=[j,@div-1-d,i]
  i0,i1,i2,i3,i4=ii[k0],ii[k1],ii[k2],ii[k3],ii[k4]
  j0,j1,j2,j3,j4=jj[k0],jj[k1],jj[k2],jj[k3],jj[k4]
  @face[f0][i0][j0],@face[f1][i1][j1],@face[f2][i2][j2],@face[f3][i3][j3],@face[f4][i4][j4]=
  @face[f1][i1][j1],@face[f2][i2][j2],@face[f3][i3][j3],@face[f4][i4][j4],@face[f0][i0][j0]
elsif i+j==2*@div-1-d
ii=[i,j,d]
jj=[j,d,i]
  i0,i1,i2,i3,i4=ii[k0],ii[k1],ii[k2],ii[k3],ii[k4]
  j0,j1,j2,j3,j4=jj[k0],jj[k1],jj[k2],jj[k3],jj[k4]
  @face[f0][i0][j0],@face[f1][i1][j1],@face[f2][i2][j2],@face[f3][i3][j3],@face[f4][i4][j4]=
  @face[f1][i1][j1],@face[f2][i2][j2],@face[f3][i3][j3],@face[f4][i4][j4],@face[f0][i0][j0]
end
  }}
  d=@div-1-d
  }
end
def rotates(k,d=0) # axis and division No.
  if d>=(@div.to_f-1)/2
    @div.times{|dd|
      rotate(k,dd) if dd>=d
    }
  else
    @div.times{|dd|
      rotate(k,dd) if dd<=d
    }
  end
end
def to_n(i=0,x=0,y=0)
  ((i*@div)+x)*@div+y
end
def to_ixy(n=0)
  i=n.to_i/(@div**2)
  xy=n.to_i%(@div**2)
  x=xy/@div
  y=xy%@div
  [i,x,y]
end

end #class

n=ARGV[0].to_i
n=3 if n==0
cube=Rubic::new(n)

v=Vector[0,0,1] # view vector
r=Vector[1,0,0] # right vector
u=Vector[0,1,0] # up vector
mx,my=0,0 # mouse
rf=0 # rotation face
rd=0 # rotation depth
su=nil # selected unit
ra=0 # rotation angle
mode=0
viewport=[0,0,400,400]
shuffle=[]

view=proc{
  angl=24.0
  w,h=viewport[2,2]
#puts 2*Math::asin(Math::sin(10.0/180*Math::PI)/w.to_f*h)/Math::PI*180
  GLU.Perspective((w>=h)?angl:
    2*Math::asin(Math::sin(angl/2/180*Math::PI)/w.to_f*h)/Math::PI*180,
    w.to_f/h, 1.0, 100.0)
  GL.Translate(0.0, 0.0, -3.0);
  vx,vy,vz=v.to_a
  ux,uy,uz=u.to_a
  GLU.LookAt(2.0*vx,2.0*vy,2.0*vz,0.0,0.0,0.0,ux,uy,uz)
}

reshape= proc {|w,h|
  GL.MatrixMode(GL::PROJECTION)
  viewport=[0,0,w,h]
  GL.Viewport(*viewport)
  GL.LoadIdentity()
  view.call
  GLUT.PostRedisplay()
}

display = proc {
  GL.Clear(GL::COLOR_BUFFER_BIT | GL::DEPTH_BUFFER_BIT)
  GL.MatrixMode(GL::MODELVIEW)
hkl=Vector[*(Rubic::Vertex[rf])]
  Rubic::Face.times{|i|
  cube.div.times{|x|
  cube.div.times{|y|
  GL.Color3d(*Rubic::Color[cube.face[i][x][y]])
  rdf=Vector[*cube.center(i,x,y)]*cube.div
  ip=rdf.inner_product(hkl)
  if (rd>=-0.2)? rd-0.5<ip : ip<rd+0.5 # all
#  if rd-0.4<ip and ip<rd+0.4 # part
    GL.Rotate(ra, *(hkl.to_a))
  end
GL.PushName(cube.to_n(i,x,y))
  GL.Begin(GL::TRIANGLES);
  cube.unit(i,x,y).each{|xx,yy,zz|
    GL.Vertex3d(xx,yy,zz)
  }
  GL.End();
GL.PopName()
  GL.LoadIdentity() unless ra==0
  }}}
  GL.Flush()
  GLUT.SwapBuffers()
}

mouse = proc{|button,state,x,y|
# p [button,state,x,y]
  mx,my=x,y
  mode=button if state==0
  if mode==2 and state==0
    sb=GL.SelectBuffer(4*4*cube.div**2)
    GL.RenderMode(GL::SELECT)
    GL.MatrixMode(GL::PROJECTION)
    GL.PushMatrix()
    GL.LoadIdentity()
# GL.GetIntegerv(GL::VIEWPORT) #viewport
    GLU.PickMatrix(x, viewport[3]-y, 4, 4, viewport)
    view.call
    display.call
    GL.MatrixMode(GL::PROJECTION)
    GL.PopMatrix()
    GL.MatrixMode(GL::MODELVIEW)
    num = GL.RenderMode(GL::RENDER)
    sb=sb.unpack("I*")
    sba=[]
    num.times{|i| sba<<sb.slice!(0,4)}
#p sba.map{|l| cube.to_ixy(l[3])}
    su=(sba==[])?nil:sba.sort_by{|x| x[1]}[0][3]
#p cube.to_ixy(su)
  end
  if mode==1 and state==0 # shuffle
    2.times{
    6.times{|i| cube.div.times{|j|
      shuffle<<[i,j,rand()]
    }}}
    shuffle=shuffle.sort_by{|l| l[2]}.map{|l| l[0..1]}
    3.times{|i| ((0...cube.div).to_a-[cube.div/2]).each{|j|
      shuffle<<[i,j,rand()]
    }}
    shuffle.reverse!
  end
  if mode==2 and state==1 # face rotation
    hkl=Vector[*(Rubic::Vertex[rf])]
    rd=(rd/(hkl.r)+(cube.div-1)/2.0).round
    (((ra.to_f/72).round)%5).times{
#      cube.rotate(rf,rd) #part
      cube.rotates(rf,rd) 
    }
    ra=0
    GLUT.PostRedisplay()
  end
  if mode==3 and state==0 # increase division
    n+=1
    cube=Rubic::new(n)
    GLUT.PostRedisplay()
  end
  if mode==4 and state==0 # decrease division
    n-=1
    n=2 if n<2
    cube=Rubic::new(n)
    GLUT.PostRedisplay()
  end
}

motion = proc{|x,y|
  dx,dy=x-mx,y-my
if mode==0 # body rotation
  dx,dy=dx*0.02,dy*0.02
  v+=r*dx+u*dy
  v*=1.0/v.r
  u-=v*dy
  u-=v*(u.inner_product(v))
  u*=1.0/u.r
  r=v.outer_product(u)
  GL.MatrixMode(GL::PROJECTION)
  GL.LoadIdentity()
  view.call
  GL.MatrixMode(GL::MODELVIEW)
  mx,my=x,y
elsif mode==2 # face rotation
  i,x,y=cube.to_ixy(su)
  dv0=r*dx+u*dy
  rfs=(0..5).to_a-Rubic::Faces[i].map{|l| l%6}
  rfb=rf
  rf,ra=rfs.map{|j|
    [j,Vector[*(Rubic::Vertex[j])].outer_product(dv0).inner_product(v)]
    }.sort_by{|l| l[1].abs}.last
  rf=rfb if ra.abs>10 # lock ratation face
  imin=[i,Rubic::Face-1-i].min
  hkl=Vector[*(Rubic::Vertex[rf])]
  rd=Vector[*cube.center(*(cube.to_ixy(su)))]*cube.div
  rd=rd.inner_product(hkl)
#p [i,rf,rd,ra]
end
  GLUT.PostRedisplay()
}

timer=proc{
  if shuffle.size>0
    hkl=Vector[*(Rubic::Vertex[0])]
    if ra==0
      rf,rd=shuffle[0] 
      rd=(rd-(cube.div-1)/2.0)*hkl.r
    end
    ra+=3*cube.div
    if ra>=72
      rd=(rd/(hkl.r)+(cube.div-1)/2.0).round
      (((ra.to_f/72).round)%5).times{
#p [rf,rd]
        cube.rotates(rf,rd) 
      }
      ra=0
      shuffle.shift
p shuffle.size
    end
    GLUT.PostRedisplay()
  end
  GLUT.TimerFunc(10, timer, 0)
}

GLUT.Init()
GLUT.InitDisplayMode(GLUT::RGBA | GLUT::DEPTH | GLUT::DOUBLE)
GLUT.CreateWindow("Rubic Icosahedron")
GL.Enable(GL::DEPTH_TEST)
#GLUT.SetCursor(GLUT::CURSOR_CYCLE)
GLUT.DisplayFunc(display)
GLUT.ReshapeFunc(reshape)
GLUT.MouseFunc(mouse)
GLUT.MotionFunc(motion)
GL.ClearColor(0.5,0.5,0.5,1.0)
#motion.call(0,0)
GLUT.TimerFunc(10, timer, 0)
GLUT.MainLoop()