Cura/gui/sceneView.py

   1 from __future__ import absolute_import
   2
   3 import wx
   4 import numpy
   5 import time
   6
   7 import OpenGL
   8 OpenGL.ERROR_CHECKING = False
   9 from OpenGL.GLU import *
  10 from OpenGL.GL import *
  11
  12 from Cura.util import profile
  13 from Cura.util import meshLoader
  14 from Cura.gui.util import opengl
  15 from Cura.gui.util import openglGui
  16
  17 class anim(object):
  18         def __init__(self, start, end, runTime):
  19                 self._start = start
  20                 self._end = end
  21                 self._startTime = time.time()
  22                 self._runTime = runTime
  23
  24         def isDone(self):
  25                 return time.time() > self._startTime + self._runTime
  26
  27         def getPosition(self):
  28                 if self.isDone():
  29                         return self._end
  30                 f = (time.time() - self._startTime) / self._runTime
  31                 ts=f*f
  32                 tc=f*f*f
  33                 f = 6*tc*ts + -15*ts*ts + 10*tc
  34                 return self._start + (self._end - self._start) * f
  35
  36 class SceneView(openglGui.glGuiPanel):
  37         def __init__(self, parent):
  38                 super(SceneView, self).__init__(parent)
  39
  40                 self._yaw = 30
  41                 self._pitch = 60
  42                 self._zoom = 300
  43                 self._objectList = []
  44                 self._objectShader = None
  45                 self._focusObj = None
  46                 self._selectedObj = None
  47                 self._objColors = [None,None,None,None]
  48                 self._mouseX = -1
  49                 self._mouseY = -1
  50                 self._mouseState = None
  51                 self._viewTarget = numpy.array([0,0,0], numpy.float32);
  52                 self._animView = None
  53                 self._animZoom = None
  54                 wx.EVT_IDLE(self, self.OnIdle)
  55                 self.updateProfileToControls()
  56
  57         def OnIdle(self, e):
  58                 if self._animView is not None or self._animZoom is not None:
  59                         self.Refresh()
  60
  61         def loadScene(self, fileList):
  62                 for filename in fileList:
  63                         for obj in meshLoader.loadMeshes(filename):
  64                                 self._objectList.append(obj)
  65
  66         def _deleteObject(self, obj):
  67                 if obj == self._selectedObj:
  68                         self._selectedObj = None
  69                 if obj == self._focusObj:
  70                         self._focusObj = None
  71                 self._objectList.remove(obj)
  72                 for m in obj._meshList:
  73                         if m.vbo is not None:
  74                                 self.glReleaseList.append(m.vbo)
  75
  76         def updateProfileToControls(self):
  77                 self._machineSize = numpy.array([profile.getPreferenceFloat('machine_width'), profile.getPreferenceFloat('machine_depth'), profile.getPreferenceFloat('machine_height')])
  78                 self._objColors[0] = profile.getPreferenceColour('model_colour')
  79                 self._objColors[1] = profile.getPreferenceColour('model_colour2')
  80                 self._objColors[2] = profile.getPreferenceColour('model_colour3')
  81                 self._objColors[3] = profile.getPreferenceColour('model_colour4')
  82
  83         def OnKeyChar(self, keyCode):
  84                 if keyCode == wx.WXK_DELETE or keyCode == wx.WXK_NUMPAD_DELETE:
  85                         if self._selectedObj is not None:
  86                                 self._deleteObject(self._selectedObj)
  87                                 self.Refresh()
  88
  89         def OnMouseDown(self,e):
  90                 self._mouseX = e.GetX()
  91                 self._mouseY = e.GetY()
  92                 if e.ButtonDClick():
  93                         self._mouseState = 'doubleClick'
  94                 else:
  95                         self._mouseState = 'dragOrClick'
  96
  97         def OnMouseUp(self, e):
  98                 if self._mouseState == 'dragOrClick':
  99                         if e.Button == 1 and self._focusObj is not None:
 100                                 self._selectedObj = self._focusObj
 101                                 newViewPos = numpy.array([self._selectedObj.getPosition()[0], self._selectedObj.getPosition()[1], self._selectedObj.getMaximum()[2] / 2])
 102                                 self._animView = anim(self._viewTarget.copy(), newViewPos, 0.5)
 103                 if self._mouseState == 'doubleClick':
 104                         if self._selectedObj is not None:
 105                                 newZoom = numpy.linalg.norm(self._selectedObj.getSize()) * 2
 106                                 self._animZoom = anim(self._zoom, newZoom, 0.5)
 107                 self._mouseState = None
 108
 109         def OnMouseMotion(self,e):
 110                 if e.Dragging():
 111                         self._mouseState == 'drag'
 112                         if not e.LeftIsDown() and e.RightIsDown():
 113                                 self._yaw += e.GetX() - self._mouseX
 114                                 self._pitch -= e.GetY() - self._mouseY
 115                                 if self._pitch > 170:
 116                                         self._pitch = 170
 117                                 if self._pitch < 10:
 118                                         self._pitch = 10
 119                         if (e.LeftIsDown() and e.RightIsDown()) or e.MiddleIsDown():
 120                                 self._zoom += e.GetY() - self._mouseY
 121                                 if self._zoom < 1:
 122                                         self._zoom = 1
 123                                 if self._zoom > numpy.max(self._machineSize) * 3:
 124                                         self._zoom = numpy.max(self._machineSize) * 3
 125                 self._mouseX = e.GetX()
 126                 self._mouseY = e.GetY()
 127
 128         def _init3DView(self):
 129                 # set viewing projection
 130                 size = self.GetSize()
 131                 glViewport(0, 0, size.GetWidth(), size.GetHeight())
 132                 glLoadIdentity()
 133
 134                 glLightfv(GL_LIGHT0, GL_POSITION, [0.2, 0.2, 1.0, 0.0])
 135
 136                 glDisable(GL_RESCALE_NORMAL)
 137                 glDisable(GL_LIGHTING)
 138                 glDisable(GL_LIGHT0)
 139                 glEnable(GL_DEPTH_TEST)
 140                 glDisable(GL_CULL_FACE)
 141                 glDisable(GL_BLEND)
 142                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
 143
 144                 glClearColor(0.8, 0.8, 0.8, 1.0)
 145                 glClearStencil(0)
 146                 glClearDepth(1.0)
 147
 148                 glMatrixMode(GL_PROJECTION)
 149                 glLoadIdentity()
 150                 aspect = float(size.GetWidth()) / float(size.GetHeight())
 151                 gluPerspective(45.0, aspect, 1.0, 1000.0)
 152
 153                 glMatrixMode(GL_MODELVIEW)
 154                 glLoadIdentity()
 155                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)
 156
 157         def OnPaint(self,e):
 158                 if self._animView is not None:
 159                         self._viewTarget = self._animView.getPosition()
 160                         if self._animView.isDone():
 161                                 self._animView = None
 162                 if self._animZoom is not None:
 163                         self._zoom = self._animZoom.getPosition()
 164                         if self._animZoom.isDone():
 165                                 self._animZoom = None
 166                 if self._objectShader is None:
 167                         self._objectShader = opengl.GLShader("""
 168 uniform float cameraDistance;
 169 varying float light_amount;
 170
 171 void main(void)
 172 {
 173     gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
 174     gl_FrontColor = gl_Color;
 175
 176         light_amount = abs(dot(normalize(gl_NormalMatrix * gl_Normal), normalize(gl_LightSource[0].position.xyz)));
 177         light_amount *= 1 - (length(gl_Position.xyz - vec3(0,0,cameraDistance)) / 1.5 / cameraDistance);
 178         light_amount += 0.2;
 179 }
 180                         ""","""
 181 uniform float cameraDistance;
 182 varying float light_amount;
 183
 184 void main(void)
 185 {
 186         gl_FragColor = vec4(gl_Color.xyz * light_amount, gl_Color[3]);
 187 }
 188                         """)
 189                 self._init3DView()
 190                 glTranslate(0,0,-self._zoom)
 191                 glRotate(-self._pitch, 1,0,0)
 192                 glRotate(self._yaw, 0,0,1)
 193                 glTranslate(-self._viewTarget[0],-self._viewTarget[1],-self._viewTarget[2])
 194                 glClearColor(1,1,1,1)
 195                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)
 196
 197                 for n in xrange(0, len(self._objectList)):
 198                         obj = self._objectList[n]
 199                         glColor4ub((n >> 24) & 0xFF, (n >> 16) & 0xFF, (n >> 8) & 0xFF, n & 0xFF)
 200                         self._renderObject(obj)
 201
 202                 if self._mouseX > -1:
 203                         n = glReadPixels(self._mouseX, self.GetSize().GetHeight() - 1 - self._mouseY, 1, 1, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8)[0][0]
 204                         if n < len(self._objectList):
 205                                 self._focusObj = self._objectList[n]
 206                         else:
 207                                 self._focusObj = None
 208
 209                 self._init3DView()
 210                 glTranslate(0,0,-self._zoom)
 211                 glRotate(-self._pitch, 1,0,0)
 212                 glRotate(self._yaw, 0,0,1)
 213                 glTranslate(-self._viewTarget[0],-self._viewTarget[1],-self._viewTarget[2])
 214
 215                 self._objectShader.bind()
 216                 self._objectShader.setUniform('cameraDistance', self._zoom)
 217                 for obj in self._objectList:
 218                         col = self._objColors[0]
 219                         if self._selectedObj == obj:
 220                                 col = map(lambda n: n * 1.5, col)
 221                         elif self._focusObj == obj:
 222                                 col = map(lambda n: n * 1.2, col)
 223                         elif self._focusObj is not None or  self._selectedObj is not None:
 224                                 col = map(lambda n: n * 0.8, col)
 225                         glColor4f(col[0], col[1], col[2], col[3])
 226                         self._renderObject(obj)
 227                 self._objectShader.unbind()
 228
 229                 self._drawMachine()
 230
 231         def _renderObject(self, obj):
 232                 glPushMatrix()
 233                 glTranslate(obj.getPosition()[0], obj.getPosition()[1], 0)
 234                 offset = obj.getDrawOffset()
 235                 glTranslate(-offset[0], -offset[1], -offset[2])
 236                 for m in obj._meshList:
 237                         if m.vbo is None:
 238                                 m.vbo = opengl.GLVBO(m.vertexes, m.normal)
 239                         m.vbo.render()
 240                 glPopMatrix()
 241
 242         def _drawMachine(self):
 243                 size = [profile.getPreferenceFloat('machine_width'), profile.getPreferenceFloat('machine_depth'), profile.getPreferenceFloat('machine_height')]
 244                 v0 = [ size[0] / 2, size[1] / 2, size[2]]
 245                 v1 = [ size[0] / 2,-size[1] / 2, size[2]]
 246                 v2 = [-size[0] / 2, size[1] / 2, size[2]]
 247                 v3 = [-size[0] / 2,-size[1] / 2, size[2]]
 248                 v4 = [ size[0] / 2, size[1] / 2, 0]
 249                 v5 = [ size[0] / 2,-size[1] / 2, 0]
 250                 v6 = [-size[0] / 2, size[1] / 2, 0]
 251                 v7 = [-size[0] / 2,-size[1] / 2, 0]
 252
 253                 vList = [v0,v1,v3,v2, v1,v0,v4,v5, v2,v3,v7,v6, v0,v2,v6,v4, v3,v1,v5,v7]
 254                 glEnable(GL_CULL_FACE)
 255                 glEnable(GL_BLEND)
 256                 glEnableClientState(GL_VERTEX_ARRAY)
 257                 glVertexPointer(3, GL_FLOAT, 3*4, vList)
 258
 259                 glColor4ub(5, 171, 231, 64)
 260                 glDrawArrays(GL_QUADS, 0, 4)
 261                 glColor4ub(5, 171, 231, 96)
 262                 glDrawArrays(GL_QUADS, 4, 8)
 263                 glColor4ub(5, 171, 231, 128)
 264                 glDrawArrays(GL_QUADS, 12, 8)
 265
 266                 sx = self._machineSize[0]
 267                 sy = self._machineSize[1]
 268                 for x in xrange(-int(sx/20)-1, int(sx / 20) + 1):
 269                         for y in xrange(-int(sx/20)-1, int(sy / 20) + 1):
 270                                 x1 = x * 10
 271                                 x2 = x1 + 10
 272                                 y1 = y * 10
 273                                 y2 = y1 + 10
 274                                 x1 = max(min(x1, sx/2), -sx/2)
 275                                 y1 = max(min(y1, sy/2), -sy/2)
 276                                 x2 = max(min(x2, sx/2), -sx/2)
 277                                 y2 = max(min(y2, sy/2), -sy/2)
 278                                 if (x & 1) == (y & 1):
 279                                         glColor4ub(5, 171, 231, 127)
 280                                 else:
 281                                         glColor4ub(5 * 8 / 10, 171 * 8 / 10, 231 * 8 / 10, 128)
 282                                 glBegin(GL_QUADS)
 283                                 glVertex3f(x1, y1, -0.02)
 284                                 glVertex3f(x2, y1, -0.02)
 285                                 glVertex3f(x2, y2, -0.02)
 286                                 glVertex3f(x1, y2, -0.02)
 287                                 glEnd()
 288
 289                 glDisableClientState(GL_VERTEX_ARRAY)
 290                 glDisable(GL_BLEND)
 291                 glDisable(GL_CULL_FACE)