#2011.5.5 shuffle method

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=8
Color=[
[0,0,1],#blue
[1,1,1],#white
[1,0.5,0],#orange,
[1,0,0],#red
[0,1,0],#green
[1,1,0],#yellow
[0,1,1],
[1,0,1],
]
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 coord(f,x,y,z) # coordination on the face
  xx,yy,zz=hkl(f)
  [x*xx,y*yy,z*zz].map{|l| l*0.5/@div}
end
def unit(f,x,y) # corner of the face
  ((x+y<@div)?[[1,0,0],[0,1,0],[0,0,1]]:[[0,1,1],[1,0,1],[1,1,0]]).map{
    |xx,yy,zz|
    (x+y<@div)? coord(f,x+xx*0.96,y+yy*0.96,@div-1-x-y+zz*0.96) :
      coord(f,@div-x-1+xx*0.98,@div-y-1+yy*0.98,x+y-@div+zz*0.98)
  }
end
def center(f,x,y) # corner of the face
  xx,yy,zz=((x+y<@div)?[1.0/3,1.0/3,1.0/3]:[2.0/3,2.0/3,2.0/3])
  (x+y<@div)? coord(f,x+xx*0.96,y+yy*0.96,@div-1-x-y+zz*0.96) :
    coord(f,@div-x-1+xx*0.98,@div-y-1+yy*0.98,x+y-@div+zz*0.98)
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
  f0=Matrix[*@face[f]].clone
  @div.times{|i|
  @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=[[1,2,4,6,5,3],[0,3,5,7,4,2],[3,0,6,4,7,1],[2,1,7,5,6,0]][k]
  f0,f1,f2,f3,f4,f5=fa
  @div.times{|i|
  @div.times{|j|
if i+j==d
  @face[f0][i][j],@face[f1][j][@div-1-d],@face[f2][@div-1-d][i]=
    @face[f2][@div-1-d][i],@face[f0][i][j],@face[f1][j][@div-1-d]
elsif i+j==2*@div-1-d
  @face[f0][i][j],@face[f1][j][d],@face[f2][d][i]=
    @face[f2][d][i],@face[f0][i][j],@face[f1][j][d]
end
if i+j==@div-1-d
  @face[f3][i][j],@face[f4][j][d],@face[f5][d][i]=
    @face[f5][d][i],@face[f3][i][j],@face[f4][j][d]
elsif i+j==@div+d
  @face[f3][i][j],@face[f4][j][@div-1-d],@face[f5][@div-1-d][i]=
    @face[f5][@div-1-d][i],@face[f3][i][j],@face[f4][j][@div-1-d]
end
  }}
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
def hkl(f)
  ("%03b"%f).split(//).map{|l| l.to_i*2-1}
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=14.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)
  Rubic::Face.times{|i|
  cube.div.times{|x|
  cube.div.times{|y|
  GL.Color3d(*Rubic::Color[cube.face[i][x][y]])
  rdc=rd-cube.div/2.0+0.5 #3d
  rdf=cube.center(i,x,y)
  rdf=Vector[*rdf]*cube.div
  hkl=Vector[*(cube.hkl(rf))]
  ip=rdf.inner_product(hkl)
#  if rdc-0.50<=ip and ip<=rdc+0.50 #
  if (rdc>=0)? ip>rdc-0.51 : ip<rdc+0.51 #
    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
#    shuffle=3*cube.div**2
    2.times{
    (Rubic::Face/2).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
#    ra=(ra.to_f/90).round*90
ra=-ra if [1,2,4,7].include?(rf)
    (((ra.to_f/120).round)%3).times{
      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..3).to_a-[i,Rubic::Face-1-i]
  rfb=rf
  rf,ra=rfs.map{|j|
    [j,Vector[*(cube.hkl(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
  if imin+rf==3
    rd=(x+y<=cube.div-1)? x : cube.div-1-x
  elsif (imin-rf).abs==2
    rd=(x+y<=cube.div-1)? cube.div-1-y : y
  else
    rd=(x+y<=cube.div-1)? x+y : 2*cube.div-1-x-y
  end
  rd=cube.div-1-rd if i>3 
end
  GLUT.PostRedisplay()
}

timer=proc{
  if shuffle.size>0
    rf,rd=shuffle[0] if ra==0
    ra+=3*cube.div
    if ra>=120
      ra=-ra if [1,2,4,7].include?(rf)
      (((ra.to_f/120).round)%3).times{
        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 Octahedron")
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()