from euclid import Matrix4

self.label = pyglet.text.Label(u'한글Hello, world',
  font_name='Gulim', # Gulim font is korean (unicode)
  font_size=20, x=200, y=200,
  anchor_x='left', anchor_y='center')

def mainloop(self):
    self.domy()
    w.flip()
  h3d.finalizeFrame()

def domy(self):
   for w in self._windows:
      camNode = w.camera

   projMat = h3d.getCameraProjMat(camNode)
   glMatrixMode( GL_PROJECTION )
   glLoadMatrixf((GLfloat * 16)(*projMat))
   
   glPushMatrix()
   glLoadIdentity
   glOrtho(0,640,0,480,0,1)
   glDisable(GL_DEPTH_TEST)
   self.label.draw()
   glPopMatrix()

   glMatrixMode( GL_MODELVIEW )
   glLoadIdentity
   glEnable(GL_DEPTH_TEST)
   camera = h3d.getNodeTransMats(camNode)
   camM = Matrix4()
   camM[:]=camera[1][:]
   glLoadMatrixf((GLfloat * 16)(*camM.inverse()[:]))
      
   a=h3d.getNodeAABB(self._knight)
   [minX, minY, minZ], [maxX, maxY, maxZ] = a[0],a[1]
   glColor3f(1.0, 1.0, 1.0)
   glBegin(GL_LINE_STRIP)
   glVertex3f(minX, minY, minZ)
   glVertex3f(maxX, minY, minZ)
   glVertex3f(maxX, maxY, minZ)
   glVertex3f(minX, maxY, minZ)
   glVertex3f(minX, minY, minZ)
   glVertex3f(minX, minY, maxZ)
   glVertex3f(maxX, minY, maxZ)
   glVertex3f(maxX, maxY, maxZ)
   glVertex3f(minX, maxY, maxZ)
   glVertex3f(minX, minY, maxZ)
   glEnd()
   glBegin(GL_LINES)
   glVertex3f(minX, maxY, minZ)
   glVertex3f(minX, maxY, maxZ)
   glVertex3f(maxX, minY, minZ)
   glVertex3f(maxX, minY, maxZ)
   glVertex3f(maxX, maxY, minZ)
   glVertex3f(maxX, maxY, maxZ)
   glEnd()
   
   pos = h3d.getNodeTransform(self._knight)
   glColor3f(1.0, 0.0, 1.0)
   glBegin(GL_LINES)
   glVertex3f(pos[0][0],pos[0][1],pos[0][2])
   glVertex3f(pos[0][0],pos[0][1]-10,pos[0][2])
   glEnd()

from euclid import Vector3,Matrix4

class Vector4:
   #Vector3, [x,y,z]
   def __init__(self, x=0, y=0, z=0, w=0):
      if isinstance(x, Vector3):
         self.x = x.x
         self.y = x.y
         self.z = x.z
         self.w = 1.
      elif isinstance(x, type([])):
         assert len(x)==3
         self.x = x[0]
         self.y = x[1]
         self.z = x[2]
         self.w = y
      else:
         self.x = x
         self.y = y
         self.z = z
         self.w = w


   def __copy__(self):
      return self.__class__(self.x, self.y, self.z,self.w)

   copy = __copy__

   def __repr__(self):
      return 'Vector4(%.2f, %.2f, %.2f, %.2f)' % (self.x, self.y, self.z,self.w)


   def __add__(self, other):
      assert isinstance(other, Vector4)
      v4 = Vector4()
      v4.x = self.x + other.x
      v4.y = self.y + other.y
      v4.z = self.z + other.z
      v4.w = self.w + other.w
      return v4

   def __mul__(self, other):
      if isinstance(other, Vector4):
         return Vector4(
               self.x * other.x,
               self.y * other.y,
               self.z * other.z,
               self.w * other.w)
      elif isinstance(other, Matrix4):
         A = other
         B = self
         V = Vector4()
         V.x = A.a * B.x  + A.b * B.y  + A.c * B.z  + A.d * B.w
         V.y = A.e * B.x  + A.f * B.y  + A.g * B.z  + A.h * B.w
         V.z = A.i * B.x  + A.j * B.y  + A.k * B.z  + A.l * B.w
         V.w = A.m * B.x  + A.n * B.y  + A.o * B.z  + A.p * B.w
         return V
      else:
         assert type(other) in (int, long, float)
         return Vector4(
               self.x * other,
               self.y * other,
               self.z * other,
               self.w * other)
   __rmul__ = __mul__

   def __imul__(self, other):
      assert type(other) in (int, long, float)
      self.x *= other
      self.y *= other
      self.z *= other
      self.w *= other
      return self

      for w in self._windows:
         camNode = w.camera
      # projection ,view matrix
      camProj = h3d.getCameraProjMat(camNode)
      projMat = Matrix4()
      projMat[:] = camProj[:]

      camTrans = h3d.getNodeTransMats(camNode)
      viewMat = Matrix4()
      viewMat[:]=camTrans[1][:]
      viewMat = viewMat.inverse();
      
      # draw hangul
      glLoadIdentity()
      glMatrixMode( GL_PROJECTION )
      glLoadIdentity()
      glOrtho(0,640,0,480,0,1)
      glDisable(GL_DEPTH_TEST)
      
      self.label.draw()
      
      #draw player name
      #nodeMat = h3d.getNodeTransMats(self._knight)
      #ppos =  Vector4(nodeMat[1][12],nodeMat[1][13],nodeMat[1][14],1)
      
      nodePos = h3d.getNodeTransform(self._knight)
      ppos =  Vector4(nodePos[0],1)
      
      ppos = ppos * (projMat * viewMat)
      if ppos.w > 0:
         x = ppos.x/ppos.w
         y = ppos.y/ppos.w
         x = int(x * 0.5 * 640 + 320)
         y = int(y * 0.5 * 480 + 240)
         self.nmLabel.x = x
         self.nmLabel.y = y
         self.nmLabel.draw()
      glEnable(GL_DEPTH_TEST)
      glLoadIdentity()