Cura/gui/util/previewTools.py

   1 from __future__ import absolute_import
   2
   3 import math
   4 import wx
   5 import numpy
   6
   7 import OpenGL
   8 OpenGL.ERROR_CHECKING = False
   9 from OpenGL.GLU import *
  10 from OpenGL.GL import *
  11
  12 from Cura.gui.util import opengl
  13
  14 class toolNone(object):
  15         def __init__(self, parent):
  16                 self.parent = parent
  17
  18         def OnMouseMove(self, p0, p1):
  19                 pass
  20
  21         def OnDragStart(self, p0, p1):
  22                 return False
  23
  24         def OnDrag(self, p0, p1):
  25                 pass
  26
  27         def OnDragEnd(self):
  28                 pass
  29
  30         def OnDraw(self):
  31                 pass
  32
  33 class toolInfo(object):
  34         def __init__(self, parent):
  35                 self.parent = parent
  36
  37         def OnMouseMove(self, p0, p1):
  38                 pass
  39
  40         def OnDragStart(self, p0, p1):
  41                 return False
  42
  43         def OnDrag(self, p0, p1):
  44                 pass
  45
  46         def OnDragEnd(self):
  47                 pass
  48
  49         def OnDraw(self):
  50                 glDisable(GL_LIGHTING)
  51                 glDisable(GL_BLEND)
  52                 glDisable(GL_DEPTH_TEST)
  53                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
  54                 glColor3ub(0,0,0)
  55                 size = self.parent.getObjectSize()
  56                 radius = self.parent.getObjectBoundaryCircle()
  57                 glPushMatrix()
  58                 glTranslate(0,0,size[2]/2 + 5)
  59                 glRotate(-self.parent.yaw, 0,0,1)
  60                 if self.parent.pitch < 80:
  61                         glTranslate(0, radius + 5,0)
  62                 elif self.parent.pitch < 100:
  63                         glTranslate(0, (radius + 5) * (90 - self.parent.pitch) / 10,0)
  64                 else:
  65                         glTranslate(0,-(radius + 5),0)
  66                 opengl.glDrawStringCenter("%dx%dx%d" % (size[0], size[1], size[2]))
  67                 glPopMatrix()
  68
  69                 glColor(255,255,255)
  70                 size = size / 2
  71                 glLineWidth(1)
  72                 glBegin(GL_LINES)
  73                 glVertex3f(size[0], size[1], size[2])
  74                 glVertex3f(size[0], size[1], size[2]/4*3)
  75                 glVertex3f(size[0], size[1], size[2])
  76                 glVertex3f(size[0], size[1]/4*3, size[2])
  77                 glVertex3f(size[0], size[1], size[2])
  78                 glVertex3f(size[0]/4*3, size[1], size[2])
  79
  80                 glVertex3f(-size[0], -size[1], size[2])
  81                 glVertex3f(-size[0], -size[1], size[2]/4*3)
  82                 glVertex3f(-size[0], -size[1], size[2])
  83                 glVertex3f(-size[0], -size[1]/4*3, size[2])
  84                 glVertex3f(-size[0], -size[1], size[2])
  85                 glVertex3f(-size[0]/4*3, -size[1], size[2])
  86
  87                 glVertex3f(size[0], -size[1], -size[2])
  88                 glVertex3f(size[0], -size[1], -size[2]/4*3)
  89                 glVertex3f(size[0], -size[1], -size[2])
  90                 glVertex3f(size[0], -size[1]/4*3, -size[2])
  91                 glVertex3f(size[0], -size[1], -size[2])
  92                 glVertex3f(size[0]/4*3, -size[1], -size[2])
  93
  94                 glVertex3f(-size[0], size[1], -size[2])
  95                 glVertex3f(-size[0], size[1], -size[2]/4*3)
  96                 glVertex3f(-size[0], size[1], -size[2])
  97                 glVertex3f(-size[0], size[1]/4*3, -size[2])
  98                 glVertex3f(-size[0], size[1], -size[2])
  99                 glVertex3f(-size[0]/4*3, size[1], -size[2])
 100                 glEnd()
 101
 102 class toolRotate(object):
 103         def __init__(self, parent):
 104                 self.parent = parent
 105                 self.rotateRingDist = 1.5
 106                 self.rotateRingDistMin = 1.3
 107                 self.rotateRingDistMax = 1.7
 108                 self.dragPlane = None
 109                 self.dragStartAngle = None
 110                 self.dragEndAngle = None
 111
 112         def _ProjectToPlanes(self, p0, p1):
 113                 cursorX0 = p0 - (p1 - p0) * (p0[0] / (p1[0] - p0[0]))
 114                 cursorY0 = p0 - (p1 - p0) * (p0[1] / (p1[1] - p0[1]))
 115                 cursorZ0 = p0 - (p1 - p0) * (p0[2] / (p1[2] - p0[2]))
 116                 cursorYZ = math.sqrt((cursorX0[1] * cursorX0[1]) + (cursorX0[2] * cursorX0[2]))
 117                 cursorXZ = math.sqrt((cursorY0[0] * cursorY0[0]) + (cursorY0[2] * cursorY0[2]))
 118                 cursorXY = math.sqrt((cursorZ0[0] * cursorZ0[0]) + (cursorZ0[1] * cursorZ0[1]))
 119                 return cursorX0, cursorY0, cursorZ0, cursorYZ, cursorXZ, cursorXY
 120
 121         def OnMouseMove(self, p0, p1):
 122                 radius = self.parent.getObjectBoundaryCircle()
 123                 cursorX0, cursorY0, cursorZ0, cursorYZ, cursorXZ, cursorXY = self._ProjectToPlanes(p0, p1)
 124                 oldDragPlane = self.dragPlane
 125                 if radius * self.rotateRingDistMin <= cursorXY <= radius * self.rotateRingDistMax or radius * self.rotateRingDistMin <= cursorYZ <= radius * self.rotateRingDistMax or radius * self.rotateRingDistMin <= cursorXZ <= radius * self.rotateRingDistMax:
 126                         self.parent.SetCursor(wx.StockCursor(wx.CURSOR_SIZING))
 127                         if self.dragStartAngle is None:
 128                                 if radius * self.rotateRingDistMin <= cursorXY <= radius * self.rotateRingDistMax:
 129                                         self.dragPlane = 'XY'
 130                                 elif radius * self.rotateRingDistMin <= cursorXZ <= radius * self.rotateRingDistMax:
 131                                         self.dragPlane = 'XZ'
 132                                 else:
 133                                         self.dragPlane = 'YZ'
 134                 else:
 135                         if self.dragStartAngle is None:
 136                                 self.dragPlane = ''
 137                         self.parent.SetCursor(wx.StockCursor(wx.CURSOR_DEFAULT))
 138
 139         def OnDragStart(self, p0, p1):
 140                 radius = self.parent.getObjectBoundaryCircle()
 141                 cursorX0, cursorY0, cursorZ0, cursorYZ, cursorXZ, cursorXY = self._ProjectToPlanes(p0, p1)
 142                 if radius * self.rotateRingDistMin <= cursorXY <= radius * self.rotateRingDistMax or radius * self.rotateRingDistMin <= cursorYZ <= radius * self.rotateRingDistMax or radius * self.rotateRingDistMin <= cursorXZ <= radius * self.rotateRingDistMax:
 143                         if radius * self.rotateRingDistMin <= cursorXY <= radius * self.rotateRingDistMax:
 144                                 self.dragPlane = 'XY'
 145                                 self.dragStartAngle = math.atan2(cursorZ0[1], cursorZ0[0]) * 180 / math.pi
 146                         elif radius * self.rotateRingDistMin <= cursorXZ <= radius * self.rotateRingDistMax:
 147                                 self.dragPlane = 'XZ'
 148                                 self.dragStartAngle = math.atan2(cursorY0[2], cursorY0[0]) * 180 / math.pi
 149                         else:
 150                                 self.dragPlane = 'YZ'
 151                                 self.dragStartAngle = math.atan2(cursorX0[2], cursorX0[1]) * 180 / math.pi
 152                         return True
 153                 return False
 154
 155         def OnDrag(self, p0, p1):
 156                 cursorX0, cursorY0, cursorZ0, cursorYZ, cursorXZ, cursorXY = self._ProjectToPlanes(p0, p1)
 157                 if self.dragPlane == 'XY':
 158                         angle = math.atan2(cursorZ0[1], cursorZ0[0]) * 180 / math.pi
 159                 elif self.dragPlane == 'XZ':
 160                         angle = math.atan2(cursorY0[2], cursorY0[0]) * 180 / math.pi
 161                 else:
 162                         angle = math.atan2(cursorX0[2], cursorX0[1]) * 180 / math.pi
 163                 diff = angle - self.dragStartAngle
 164                 if wx.GetKeyState(wx.WXK_SHIFT):
 165                         diff = round(diff / 1) * 1
 166                 else:
 167                         diff = round(diff / 15) * 15
 168                 if diff > 180:
 169                         diff -= 360
 170                 if diff < -180:
 171                         diff += 360
 172                 rad = diff / 180.0 * math.pi
 173                 self.dragEndAngle = self.dragStartAngle + diff
 174                 if self.dragPlane == 'XY':
 175                         self.parent.tempMatrix = numpy.matrix([[math.cos(rad), math.sin(rad), 0], [-math.sin(rad), math.cos(rad), 0], [0,0,1]], numpy.float64)
 176                 elif self.dragPlane == 'XZ':
 177                         self.parent.tempMatrix = numpy.matrix([[math.cos(rad), 0, math.sin(rad)], [0,1,0], [-math.sin(rad), 0, math.cos(rad)]], numpy.float64)
 178                 else:
 179                         self.parent.tempMatrix = numpy.matrix([[1,0,0], [0, math.cos(rad), math.sin(rad)], [0, -math.sin(rad), math.cos(rad)]], numpy.float64)
 180
 181         def OnDragEnd(self):
 182                 self.dragStartAngle = None
 183
 184         def OnDraw(self):
 185                 glDisable(GL_LIGHTING)
 186                 glDisable(GL_BLEND)
 187                 glDisable(GL_DEPTH_TEST)
 188                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
 189                 radius = self.parent.getObjectBoundaryCircle()
 190                 glScalef(self.rotateRingDist * radius, self.rotateRingDist * radius, self.rotateRingDist * radius)
 191                 if self.dragPlane == 'XY':
 192                         glLineWidth(3)
 193                         glColor4ub(255,64,64,255)
 194                         if self.dragStartAngle is not None:
 195                                 glPushMatrix()
 196                                 glRotate(self.dragStartAngle, 0,0,1)
 197                                 glBegin(GL_LINES)
 198                                 glVertex3f(0,0,0)
 199                                 glVertex3f(1,0,0)
 200                                 glEnd()
 201                                 glPopMatrix()
 202                                 glPushMatrix()
 203                                 glRotate(self.dragEndAngle, 0,0,1)
 204                                 glBegin(GL_LINES)
 205                                 glVertex3f(0,0,0)
 206                                 glVertex3f(1,0,0)
 207                                 glEnd()
 208                                 glTranslatef(1.1,0,0)
 209                                 glColor4ub(0,0,0,255)
 210                                 opengl.glDrawStringCenter("%d" % (abs(self.dragEndAngle - self.dragStartAngle)))
 211                                 glColor4ub(255,64,64,255)
 212                                 glPopMatrix()
 213                 else:
 214                         glLineWidth(1)
 215                         glColor4ub(128,0,0,255)
 216                 glBegin(GL_LINE_LOOP)
 217                 for i in xrange(0, 64):
 218                         glVertex3f(math.cos(i/32.0*math.pi), math.sin(i/32.0*math.pi),0)
 219                 glEnd()
 220                 if self.dragPlane == 'YZ':
 221                         glColor4ub(64,255,64,255)
 222                         glLineWidth(3)
 223                         if self.dragStartAngle is not None:
 224                                 glPushMatrix()
 225                                 glRotate(self.dragStartAngle, 1,0,0)
 226                                 glBegin(GL_LINES)
 227                                 glVertex3f(0,0,0)
 228                                 glVertex3f(0,1,0)
 229                                 glEnd()
 230                                 glPopMatrix()
 231                                 glPushMatrix()
 232                                 glRotate(self.dragEndAngle, 1,0,0)
 233                                 glBegin(GL_LINES)
 234                                 glVertex3f(0,0,0)
 235                                 glVertex3f(0,1,0)
 236                                 glEnd()
 237                                 glTranslatef(0,1.1,0)
 238                                 glColor4ub(0,0,0,255)
 239                                 opengl.glDrawStringCenter("%d" % (abs(self.dragEndAngle - self.dragStartAngle)))
 240                                 glColor4ub(64,255,64,255)
 241                                 glPopMatrix()
 242                 else:
 243                         glColor4ub(0,128,0,255)
 244                         glLineWidth(1)
 245                 glBegin(GL_LINE_LOOP)
 246                 for i in xrange(0, 64):
 247                         glVertex3f(0, math.cos(i/32.0*math.pi), math.sin(i/32.0*math.pi))
 248                 glEnd()
 249                 if self.dragPlane == 'XZ':
 250                         glLineWidth(3)
 251                         glColor4ub(255,255,0,255)
 252                         if self.dragStartAngle is not None:
 253                                 glPushMatrix()
 254                                 glRotate(self.dragStartAngle, 0,-1,0)
 255                                 glBegin(GL_LINES)
 256                                 glVertex3f(0,0,0)
 257                                 glVertex3f(1,0,0)
 258                                 glEnd()
 259                                 glPopMatrix()
 260                                 glPushMatrix()
 261                                 glRotate(self.dragEndAngle, 0,-1,0)
 262                                 glBegin(GL_LINES)
 263                                 glVertex3f(0,0,0)
 264                                 glVertex3f(1,0,0)
 265                                 glEnd()
 266                                 glTranslatef(1.1,0,0)
 267                                 glColor4ub(0,0,0,255)
 268                                 opengl.glDrawStringCenter("%d" % (abs(self.dragEndAngle - self.dragStartAngle)))
 269                                 glColor4ub(255,255,0,255)
 270                                 glPopMatrix()
 271                 else:
 272                         glColor4ub(128,128,0,255)
 273                         glLineWidth(1)
 274                 glBegin(GL_LINE_LOOP)
 275                 for i in xrange(0, 64):
 276                         glVertex3f(math.cos(i/32.0*math.pi), 0, math.sin(i/32.0*math.pi))
 277                 glEnd()
 278                 glEnable(GL_DEPTH_TEST)
 279
 280 class toolScale(object):
 281         def __init__(self, parent):
 282                 self.parent = parent
 283                 self.node = None
 284                 self.scale = None
 285
 286         def _pointDist(self, p0, p1, p2):
 287                 return numpy.linalg.norm(numpy.cross((p0 - p1), (p0 - p2))) / numpy.linalg.norm(p2 - p1)
 288
 289         def _traceNodes(self, p0, p1):
 290                 s = self._nodeSize()
 291                 if self._pointDist(numpy.array([0,0,0],numpy.float32), p0, p1) < s * 2:
 292                         return 1
 293                 if self._pointDist(numpy.array([s*15,0,0],numpy.float32), p0, p1) < s * 2:
 294                         return 2
 295                 if self._pointDist(numpy.array([0,s*15,0],numpy.float32), p0, p1) < s * 2:
 296                         return 3
 297                 if self._pointDist(numpy.array([0,0,s*15],numpy.float32), p0, p1) < s * 2:
 298                         return 4
 299                 return None
 300
 301         def _lineLineCrossingDistOnLine(self, s0, e0, s1, e1):
 302                 d0 = e0 - s0
 303                 d1 = e1 - s1
 304                 a = numpy.dot(d0, d0)
 305                 b = numpy.dot(d0, d1)
 306                 e = numpy.dot(d1, d1)
 307                 d = a*e - b*b
 308
 309                 r = s0 - s1
 310                 c = numpy.dot(d0, r)
 311                 f = numpy.dot(d1, r)
 312
 313                 s = (b*f - c*e) / d
 314                 t = (a*f - b*c) / d
 315                 return t
 316
 317         def _nodeSize(self):
 318                 return float(self.parent.zoom) / float(self.parent.GetSize().GetWidth()) * 6.0
 319
 320         def OnMouseMove(self, p0, p1):
 321                 self.node = self._traceNodes(p0, p1)
 322
 323         def OnDragStart(self, p0, p1):
 324                 if self.node is None:
 325                         return False
 326                 return True
 327
 328         def OnDrag(self, p0, p1):
 329                 s = self._nodeSize()
 330                 endPoint = [1,1,1]
 331                 if self.node == 2:
 332                         endPoint = [1,0,0]
 333                 elif self.node == 3:
 334                         endPoint = [0,1,0]
 335                 elif self.node == 4:
 336                         endPoint = [0,0,1]
 337                 scale = self._lineLineCrossingDistOnLine(p0, p1, numpy.array([0,0,0], numpy.float32), numpy.array(endPoint, numpy.float32)) / 15.0 / s
 338                 if not wx.GetKeyState(wx.WXK_SHIFT):
 339                         objMatrix = self.parent.getObjectMatrix()
 340                         scaleX = numpy.linalg.norm(objMatrix[0].getA().flatten())
 341                         scaleY = numpy.linalg.norm(objMatrix[1].getA().flatten())
 342                         scaleZ = numpy.linalg.norm(objMatrix[2].getA().flatten())
 343                         if self.node == 1 or not wx.GetKeyState(wx.WXK_CONTROL):
 344                                 matrixScale = (scaleX + scaleY + scaleZ) / 3
 345                         elif self.node == 2:
 346                                 matrixScale = scaleX
 347                         elif self.node == 3:
 348                                 matrixScale = scaleY
 349                         elif self.node == 4:
 350                                 matrixScale = scaleZ
 351                         scale = (round((matrixScale * scale) * 10) / 10) / matrixScale
 352                 if scale < 0:
 353                         scale = -scale
 354                 if scale < 0.1:
 355                         scale = 0.1
 356                 self.scale = scale
 357                 if self.node == 1 or not wx.GetKeyState(wx.WXK_CONTROL):
 358                         self.parent.tempMatrix = numpy.matrix([[scale,0,0], [0, scale, 0], [0, 0, scale]], numpy.float64)
 359                 elif self.node == 2:
 360                         self.parent.tempMatrix = numpy.matrix([[scale,0,0], [0, 1, 0], [0, 0, 1]], numpy.float64)
 361                 elif self.node == 3:
 362                         self.parent.tempMatrix = numpy.matrix([[1,0,0], [0, scale, 0], [0, 0, 1]], numpy.float64)
 363                 elif self.node == 4:
 364                         self.parent.tempMatrix = numpy.matrix([[1,0,0], [0, 1, 0], [0, 0, scale]], numpy.float64)
 365
 366         def OnDragEnd(self):
 367                 self.scale = None
 368
 369         def OnDraw(self):
 370                 s = self._nodeSize()
 371                 sx = s*15
 372                 sy = s*15
 373                 sz = s*15
 374                 if self.node == 2 and self.scale is not None:
 375                         sx *= self.scale
 376                 if self.node == 3 and self.scale is not None:
 377                         sy *= self.scale
 378                 if self.node == 4 and self.scale is not None:
 379                         sz *= self.scale
 380                 objMatrix = self.parent.getObjectMatrix()
 381                 scaleX = numpy.linalg.norm(objMatrix[0].getA().flatten())
 382                 scaleY = numpy.linalg.norm(objMatrix[1].getA().flatten())
 383                 scaleZ = numpy.linalg.norm(objMatrix[2].getA().flatten())
 384                 if self.scale is not None:
 385                         scaleX *= self.scale
 386                         scaleY *= self.scale
 387                         scaleZ *= self.scale
 388
 389                 glDisable(GL_LIGHTING)
 390                 glDisable(GL_DEPTH_TEST)
 391                 glEnable(GL_BLEND)
 392                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
 393
 394                 glColor3ub(0,0,0)
 395                 size = self.parent.getObjectSize()
 396                 radius = self.parent.getObjectBoundaryCircle()
 397                 if self.scale is not None:
 398                         radius *= self.scale
 399                 glPushMatrix()
 400                 glTranslate(0,0,size[2]/2 + 5)
 401                 glRotate(-self.parent.yaw, 0,0,1)
 402                 if self.parent.pitch < 80:
 403                         glTranslate(0, radius + 5,0)
 404                 elif self.parent.pitch < 100:
 405                         glTranslate(0, (radius + 5) * (90 - self.parent.pitch) / 10,0)
 406                 else:
 407                         glTranslate(0,-(radius + 5),0)
 408                 if self.parent.tempMatrix is not None:
 409                         size = (numpy.matrix([size]) * self.parent.tempMatrix).getA().flatten()
 410                 opengl.glDrawStringCenter("W, D, H: %0.1f, %0.1f, %0.1f mm" % (size[0], size[1], size[2]))
 411                 glPopMatrix()
 412
 413                 glLineWidth(1)
 414                 glBegin(GL_LINES)
 415                 glColor3ub(128,0,0)
 416                 glVertex3f(0, 0, 0)
 417                 glVertex3f(sx, 0, 0)
 418                 glColor3ub(128,128,0)
 419                 glVertex3f(0, 0, 0)
 420                 glVertex3f(0, sy, 0)
 421                 glColor3ub(0,128,0)
 422                 glVertex3f(0, 0, 0)
 423                 glVertex3f(0, 0, sz)
 424                 glEnd()
 425
 426                 glLineWidth(2)
 427                 if self.node == 1:
 428                         glColor3ub(255,255,255)
 429                 else:
 430                         glColor3ub(192,192,192)
 431                 opengl.DrawBox([-s,-s,-s], [s,s,s])
 432                 if self.node == 1:
 433                         glColor3ub(0,0,0)
 434                         opengl.glDrawStringCenter("%0.2f" % ((scaleX + scaleY + scaleZ) / 3.0))
 435
 436                 if self.node == 2:
 437                         glColor3ub(255,64,64)
 438                 else:
 439                         glColor3ub(128,0,0)
 440                 glPushMatrix()
 441                 glTranslatef(sx,0,0)
 442                 opengl.DrawBox([-s,-s,-s], [s,s,s])
 443                 if self.node == 2:
 444                         glColor3ub(0,0,0)
 445                         opengl.glDrawStringCenter("%0.2f" % (scaleX))
 446                 glPopMatrix()
 447                 if self.node == 3:
 448                         glColor3ub(255,255,0)
 449                 else:
 450                         glColor3ub(128,128,0)
 451                 glPushMatrix()
 452                 glTranslatef(0,sy,0)
 453                 opengl.DrawBox([-s,-s,-s], [s,s,s])
 454                 if self.node == 3:
 455                         glColor3ub(0,0,0)
 456                         opengl.glDrawStringCenter("%0.2f" % (scaleY))
 457                 glPopMatrix()
 458                 if self.node == 4:
 459                         glColor3ub(64,255,64)
 460                 else:
 461                         glColor3ub(0,128,0)
 462                 glPushMatrix()
 463                 glTranslatef(0,0,sz)
 464                 opengl.DrawBox([-s,-s,-s], [s,s,s])
 465                 if self.node == 4:
 466                         glColor3ub(0,0,0)
 467                         opengl.glDrawStringCenter("%0.2f" % (scaleZ))
 468                 glPopMatrix()
 469
 470                 glEnable(GL_DEPTH_TEST)
 471                 glColor(255,255,255)
 472                 size = size / 2
 473                 size += 0.01
 474                 glLineWidth(1)
 475                 glBegin(GL_LINES)
 476                 glVertex3f(size[0], size[1], size[2])
 477                 glVertex3f(size[0], size[1], size[2]/4*3)
 478                 glVertex3f(size[0], size[1], size[2])
 479                 glVertex3f(size[0], size[1]/4*3, size[2])
 480                 glVertex3f(size[0], size[1], size[2])
 481                 glVertex3f(size[0]/4*3, size[1], size[2])
 482
 483                 glVertex3f(-size[0], size[1], size[2])
 484                 glVertex3f(-size[0], size[1], size[2]/4*3)
 485                 glVertex3f(-size[0], size[1], size[2])
 486                 glVertex3f(-size[0], size[1]/4*3, size[2])
 487                 glVertex3f(-size[0], size[1], size[2])
 488                 glVertex3f(-size[0]/4*3, size[1], size[2])
 489
 490                 glVertex3f(size[0], -size[1], size[2])
 491                 glVertex3f(size[0], -size[1], size[2]/4*3)
 492                 glVertex3f(size[0], -size[1], size[2])
 493                 glVertex3f(size[0], -size[1]/4*3, size[2])
 494                 glVertex3f(size[0], -size[1], size[2])
 495                 glVertex3f(size[0]/4*3, -size[1], size[2])
 496
 497                 glVertex3f(-size[0], -size[1], size[2])
 498                 glVertex3f(-size[0], -size[1], size[2]/4*3)
 499                 glVertex3f(-size[0], -size[1], size[2])
 500                 glVertex3f(-size[0], -size[1]/4*3, size[2])
 501                 glVertex3f(-size[0], -size[1], size[2])
 502                 glVertex3f(-size[0]/4*3, -size[1], size[2])
 503
 504                 glVertex3f(size[0], size[1], -size[2])
 505                 glVertex3f(size[0], size[1], -size[2]/4*3)
 506                 glVertex3f(size[0], size[1], -size[2])
 507                 glVertex3f(size[0], size[1]/4*3, -size[2])
 508                 glVertex3f(size[0], size[1], -size[2])
 509                 glVertex3f(size[0]/4*3, size[1], -size[2])
 510
 511                 glVertex3f(-size[0], size[1], -size[2])
 512                 glVertex3f(-size[0], size[1], -size[2]/4*3)
 513                 glVertex3f(-size[0], size[1], -size[2])
 514                 glVertex3f(-size[0], size[1]/4*3, -size[2])
 515                 glVertex3f(-size[0], size[1], -size[2])
 516                 glVertex3f(-size[0]/4*3, size[1], -size[2])
 517
 518                 glVertex3f(size[0], -size[1], -size[2])
 519                 glVertex3f(size[0], -size[1], -size[2]/4*3)
 520                 glVertex3f(size[0], -size[1], -size[2])
 521                 glVertex3f(size[0], -size[1]/4*3, -size[2])
 522                 glVertex3f(size[0], -size[1], -size[2])
 523                 glVertex3f(size[0]/4*3, -size[1], -size[2])
 524
 525                 glVertex3f(-size[0], -size[1], -size[2])
 526                 glVertex3f(-size[0], -size[1], -size[2]/4*3)
 527                 glVertex3f(-size[0], -size[1], -size[2])
 528                 glVertex3f(-size[0], -size[1]/4*3, -size[2])
 529                 glVertex3f(-size[0], -size[1], -size[2])
 530                 glVertex3f(-size[0]/4*3, -size[1], -size[2])
 531                 glEnd()
 532
 533                 glEnable(GL_DEPTH_TEST)