Scenegraph refactor part 2

Move Node types into separate files and keep them with their RenderNodes

Eww, fully qualified imports everywhere

src/mcedit2/editortools/brush/__init__.py

@@ -13,6 +13,7 @@ from mcedit2.editortools.brush.modes import BrushModes
 from mcedit2.rendering import worldscene
 from mcedit2.rendering.scenegraph import scenenode
 from mcedit2.rendering.depths import DepthOffset
+import mcedit2.rendering.scenegraph.matrix
 from mcedit2.rendering.selection import SelectionBoxNode
 from mcedit2.util.load_ui import load_ui, registerCustomWidget
 from mcedit2.util.settings import Settings
@@ -104,7 +105,7 @@ class BrushTool(EditorTool):
         BrushModeSetting.connectAndCall(self.modeSettingChanged)
 
         self.cursorWorldScene = None
-        self.cursorNode = scenenode.TranslateNode()
+        self.cursorNode = mcedit2.rendering.scenegraph.matrix.TranslateNode()
 
         self.toolWidget.xSpinSlider.setMinimum(1)
         self.toolWidget.ySpinSlider.setMinimum(1)

src/mcedit2/editortools/generate.py

@@ -11,6 +11,7 @@ from mcedit2.command import SimpleRevisionCommand
 from mcedit2.editortools import EditorTool
 from mcedit2.handles.boxhandle import BoxHandle
 from mcedit2.rendering.scenegraph import scenenode
+import mcedit2.rendering.scenegraph.matrix
 from mcedit2.rendering.worldscene import WorldScene
 from mcedit2.util.showprogress import showProgress
 from mcedit2.util.worldloader import WorldLoader
@@ -208,7 +209,7 @@ class GenerateTool(EditorTool):
 
         self.overlayNode = scenenode.Node()
 
-        self.sceneHolderNode = scenenode.TranslateNode()
+        self.sceneHolderNode = mcedit2.rendering.scenegraph.matrix.TranslateNode()
         self.overlayNode.addChild(self.sceneHolderNode)
 
         self.previewNode = None

src/mcedit2/editortools/move.py

@@ -10,6 +10,7 @@ from PySide.QtCore import Qt
 from mcedit2.editorsession import PendingImport
 from mcedit2.editortools import EditorTool
 from mcedit2.command import SimpleRevisionCommand
+import mcedit2.rendering.scenegraph.matrix
 from mcedit2.rendering.selection import SelectionBoxNode, SelectionFaceNode, boxFaceUnderCursor
 from mcedit2.rendering.scenegraph import scenenode
 from mcedit2.rendering.depths import DepthOffset
@@ -119,7 +120,7 @@ class CoordinateWidget(QtGui.QWidget):
         x, y, z = self.point
         self.point = Vector(x, y, value)
 
-class PendingImportNode(scenenode.TranslateNode):
+class PendingImportNode(mcedit2.rendering.scenegraph.matrix.TranslateNode):
     def __init__(self, pendingImport, textureAtlas):
         super(PendingImportNode, self).__init__()
         self.pendingImport = pendingImport

src/mcedit2/rendering/chunkmeshes/chunksections.py

@@ -12,6 +12,7 @@ from mcedit2.rendering.scenegraph import scenenode
 from mcedit2.rendering.blockmeshes import standardCubeTemplates
 from mcedit2.rendering.blockmeshes import ChunkMeshBase
 from mcedit2.rendering.layers import Layer
+import mcedit2.rendering.scenegraph.vertex_array
 from mcedit2.rendering.slices import _XYZ, _RGBA
 from mcedit2.rendering.vertexarraybuffer import VertexArrayBuffer
 
@@ -35,6 +36,6 @@ class ChunkSectionsRenderer(ChunkMeshBase):
             buffer.buffer[i, :] = self.vertexTemplate
             buffer.vertex[i, ..., 1] += cy * 16
 
-        self.sceneNode = scenenode.VertexNode(buffer)
+        self.sceneNode = mcedit2.rendering.scenegraph.vertex_array.VertexNode(buffer)
 
         yield

src/mcedit2/rendering/chunkmeshes/entitymesh.py

@@ -13,7 +13,11 @@ from mcedit2.rendering.blockmeshes import standardCubeTemplates
 from mcedit2.rendering.blockmeshes import ChunkMeshBase
 from mcedit2.rendering.chunkmeshes.entity import models
 from mcedit2.rendering.layers import Layer
-from mcedit2.rendering.scenegraph.scenenode import PolygonModeNode, DepthFuncNode
+import mcedit2.rendering.scenegraph.bind_texture
+import mcedit2.rendering.scenegraph.matrix
+from mcedit2.rendering.scenegraph.misc import PolygonModeNode
+from mcedit2.rendering.scenegraph.depth_test import DepthFuncNode
+import mcedit2.rendering.scenegraph.vertex_array
 from mcedit2.rendering.slices import _XYZ
 from mcedit2.rendering.vertexarraybuffer import QuadVertexArrayBuffer
 from mceditlib.anvil.entities import PCPaintingEntityRefBase
@@ -65,7 +69,7 @@ class TileEntityMesh(EntityMeshBase):
 
         tiles = self._computeVertices(tilePositions, (0xff, 0xff, 0x33, 0x44), chunkPosition=chunk.chunkPosition)
         yield
-        self.sceneNode = scenenode.VertexNode(tiles)
+        self.sceneNode = mcedit2.rendering.scenegraph.vertex_array.VertexNode(tiles)
 
 
 
@@ -111,9 +115,9 @@ class ItemFrameMesh(EntityMeshBase):
             texCorners = [(1, 1), (1, 0), (0, 0), (0, 1)]
             vertexBuffer.texcoord[:] += texCorners
 
-            vertexNode = scenenode.VertexNode([vertexBuffer])
+            vertexNode = mcedit2.rendering.scenegraph.vertex_array.VertexNode([vertexBuffer])
             if mapTex is not None:
-                bindTexNode = scenenode.BindTextureNode(mapTex)
+                bindTexNode = mcedit2.rendering.scenegraph.bind_texture.BindTextureNode(mapTex)
                 bindTexNode.addChild(vertexNode)
                 nodes.append(bindTexNode)
             else:
@@ -153,15 +157,15 @@ class MonsterModelRenderer(ChunkMeshBase):
             vertexBuffer.vertex[:] = modelVerts[..., :3]
             vertexBuffer.texcoord[:] = modelVerts[..., 3:5]
 
-            node = scenenode.VertexNode(vertexBuffer)
-            rotateNode = scenenode.RotateNode(ref.Rotation[0], (0., 1., 0.))
+            node = mcedit2.rendering.scenegraph.vertex_array.VertexNode(vertexBuffer)
+            rotateNode = mcedit2.rendering.scenegraph.matrix.RotateNode(ref.Rotation[0], (0., 1., 0.))
             rotateNode.addChild(node)
-            translateNode = scenenode.TranslateNode((ref.Position - (chunk.cx << 4, 0, chunk.cz << 4)))
+            translateNode = mcedit2.rendering.scenegraph.matrix.TranslateNode((ref.Position - (chunk.cx << 4, 0, chunk.cz << 4)))
             translateNode.addChild(rotateNode)
 
             modelTex = self.chunkUpdate.updateTask.getModelTexture(models.textures[ID])
 
-            textureNode = scenenode.BindTextureNode(modelTex, (1./modelTex.w, 1./modelTex.h, 1))
+            textureNode = mcedit2.rendering.scenegraph.bind_texture.BindTextureNode(modelTex, (1./modelTex.w, 1./modelTex.h, 1))
             textureNode.addChild(translateNode)
             sceneNode.addChild(textureNode)
 
@@ -194,7 +198,7 @@ class MonsterRenderer(EntityMeshBase):
                                          chunkPosition=chunk.chunkPosition)
         yield
 
-        vertexNode = scenenode.VertexNode(monsters)
+        vertexNode = mcedit2.rendering.scenegraph.vertex_array.VertexNode(monsters)
         polyNode = PolygonModeNode(GL.GL_FRONT_AND_BACK, GL.GL_LINE)
         polyNode.addChild(vertexNode)
         depthNode = DepthFuncNode(GL.GL_ALWAYS)
@@ -232,5 +236,5 @@ class ItemRenderer(EntityMeshBase):
                                          numpy.array(entityColors, dtype='uint8')[:, numpy.newaxis, numpy.newaxis],
                                          offset=True, chunkPosition=chunk.chunkPosition)
         yield
-        self.sceneNode = scenenode.VertexNode(items)
+        self.sceneNode = mcedit2.rendering.scenegraph.vertex_array.VertexNode(items)
 

src/mcedit2/rendering/chunkmeshes/lowdetail.py

@@ -10,6 +10,7 @@ from mcedit2.rendering import renderstates
 from mcedit2.rendering.scenegraph import scenenode
 from mcedit2.rendering.blockmeshes import standardCubeTemplates
 from mcedit2.rendering.blockmeshes import ChunkMeshBase
+import mcedit2.rendering.scenegraph.vertex_array
 from mcedit2.rendering.vertexarraybuffer import QuadVertexArrayBuffer
 from mceditlib import faces
 
@@ -101,7 +102,7 @@ class LowDetailBlockMesh(ChunkMeshBase):
 
         yield
         if self.detailLevel == 2:
-            self.sceneNode = scenenode.VertexNode(va0)
+            self.sceneNode = mcedit2.rendering.scenegraph.vertex_array.VertexNode(va0)
             return
 
         # Calculate how deep each column needs to go to be flush with the adjacent column;
@@ -136,7 +137,7 @@ class LowDetailBlockMesh(ChunkMeshBase):
         va2.vertex[:, (0, 3), 0] -= 1.0  # turn diagonally
 
 
-        nodes = [scenenode.VertexNode(v) for v in (va1, va2, va0)]
+        nodes = [mcedit2.rendering.scenegraph.vertex_array.VertexNode(v) for v in (va1, va2, va0)]
 
         self.sceneNode = scenenode.Node()
         for node in nodes:

src/mcedit2/rendering/chunkmeshes/terrainpop.py

@@ -11,6 +11,7 @@ from mcedit2.rendering.scenegraph import scenenode
 from mcedit2.rendering.blockmeshes import standardCubeTemplates
 from mcedit2.rendering.blockmeshes import ChunkMeshBase
 from mcedit2.rendering.layers import Layer
+import mcedit2.rendering.scenegraph.vertex_array
 from mcedit2.rendering.slices import _XYZ, _RGBA
 from mcedit2.rendering.vertexarraybuffer import QuadVertexArrayBuffer
 from mceditlib import faces
@@ -89,6 +90,6 @@ class TerrainPopulatedRenderer(ChunkMeshBase):
         verts = self.vertexTemplate[visibleFaces]
         buffer = QuadVertexArrayBuffer(0, textures=False, lights=False)
         buffer.buffer = verts
-        self.sceneNode = scenenode.VertexNode(buffer)
+        self.sceneNode = mcedit2.rendering.scenegraph.vertex_array.VertexNode(buffer)
 
         yield

src/mcedit2/rendering/chunkmeshes/tileticks.py

@@ -7,6 +7,7 @@ import logging
 from mcedit2.rendering.scenegraph import scenenode
 from mcedit2.rendering.chunkmeshes.entitymesh import EntityMeshBase
 from mcedit2.rendering.layers import Layer
+import mcedit2.rendering.scenegraph.vertex_array
 
 log = logging.getLogger(__name__)
 
@@ -18,7 +19,7 @@ class TileTicksRenderer(EntityMeshBase):
         if hasattr(chunk, "TileTicks"):
             ticks = chunk.TileTicks
             if len(ticks):
-                self.sceneNode = scenenode.VertexNode(
+                self.sceneNode = mcedit2.rendering.scenegraph.vertex_array.VertexNode(
                     self._computeVertices([[t[i].value for i in "xyz"] for t in ticks],
                                           (0xff, 0xff, 0xff, 0x44),
                                           chunkPosition=chunk.chunkPosition))

src/mcedit2/rendering/chunknode.py

@@ -5,13 +5,14 @@ from __future__ import absolute_import, division, print_function
 import logging
 
 from mcedit2.rendering.scenegraph import scenenode, rendernode
+import mcedit2.rendering.scenegraph.matrix
 from mcedit2.rendering.scenegraph.scenenode import NamedChildrenNode
 
 
 log = logging.getLogger(__name__)
 
 class ChunkNode(scenenode.Node):
-    RenderNodeClass = rendernode.TranslateRenderNode
+    RenderNodeClass = mcedit2.rendering.scenegraph.matrix.TranslateRenderNode
 
     def __init__(self, chunkPosition):
         """

src/mcedit2/rendering/modelmesh.pyx

@@ -8,7 +8,7 @@ import logging
 cimport numpy
 
 from mcedit2.rendering import renderstates
-from mcedit2.rendering.scenegraph import scenenode
+from mcedit2.rendering.scenegraph.vertex_array import VertexNode
 from mcedit2.rendering.layers import Layer
 from mcedit2.rendering.vertexarraybuffer import QuadVertexArrayBuffer
 cimport mcedit2.rendering.blockmodels as blockmodels
@@ -304,5 +304,5 @@ class BlockModelMesh(object):
             vertexArray = QuadVertexArrayBuffer(buffer_ptr)
             vabuffer = vertexArray.buffer
             memcpy(vabuffer.data, vertexBuffer, buffer_ptr * sizeof(float) * quadFloats)
-            self.sceneNode = scenenode.VertexNode(vertexArray)
+            self.sceneNode = VertexNode(vertexArray)
         free(vertexBuffer)

src/mcedit2/rendering/scenegraph/bind_texture.py

@@ -0,0 +1,44 @@
+"""
+    bind_texture
+"""
+from __future__ import absolute_import, division, print_function, unicode_literals
+import logging
+from OpenGL import GL
+from mcedit2.rendering.scenegraph import rendernode
+from mcedit2.rendering.scenegraph.rendernode import RenderstateRenderNode
+from mcedit2.rendering.scenegraph.scenenode import Node
+from mcedit2.util import glutils
+
+log = logging.getLogger(__name__)
+
+
+class BindTextureRenderNode(RenderstateRenderNode):
+    def enter(self):
+        GL.glPushAttrib(GL.GL_ENABLE_BIT | GL.GL_TEXTURE_BIT)
+        GL.glMatrixMode(GL.GL_TEXTURE)
+        GL.glPushMatrix()
+        GL.glLoadIdentity()
+        scale = self.sceneNode.scale
+        if scale is not None:
+            GL.glScale(*scale)
+        glutils.glActiveTexture(GL.GL_TEXTURE0)
+        GL.glEnable(GL.GL_TEXTURE_2D)
+        self.sceneNode.texture.bind()
+
+    def exit(self):
+        GL.glMatrixMode(GL.GL_TEXTURE)
+        GL.glPopMatrix()
+        GL.glPopAttrib()
+
+
+class BindTextureNode(Node):
+    RenderNodeClass = BindTextureRenderNode
+
+    def __init__(self, texture, scale=None):
+        """
+
+        :type texture: glutils.Texture
+        """
+        super(BindTextureNode, self).__init__()
+        self.texture = texture
+        self.scale = scale

src/mcedit2/rendering/scenegraph/depth_test.py

@@ -0,0 +1,59 @@
+"""
+    depth_test
+"""
+from __future__ import absolute_import, division, print_function, unicode_literals
+import logging
+from OpenGL import GL
+from mcedit2.rendering.scenegraph.rendernode import RenderstateRenderNode
+from mcedit2.rendering.scenegraph.scenenode import Node
+
+log = logging.getLogger(__name__)
+
+
+class DepthMaskRenderNode(RenderstateRenderNode):
+    def enter(self):
+        GL.glPushAttrib(GL.GL_DEPTH_BUFFER_BIT)
+        GL.glDepthMask(self.sceneNode.mask)
+
+    def exit(self):
+        GL.glPopAttrib()
+
+
+class DepthMaskNode(Node):
+    RenderNodeClass = DepthMaskRenderNode
+    mask = False
+
+
+class DepthFuncRenderNode(RenderstateRenderNode):
+    def enter(self):
+        GL.glPushAttrib(GL.GL_DEPTH_BUFFER_BIT)
+        GL.glDepthFunc(self.sceneNode.func)
+
+    def exit(self):
+        GL.glPopAttrib()
+
+
+class DepthFuncNode(Node):
+    RenderNodeClass = DepthFuncRenderNode
+
+    def __init__(self, func=GL.GL_LESS):
+        super(DepthFuncNode, self).__init__()
+        self.func = func
+
+
+class DepthOffsetRenderNode(RenderstateRenderNode):
+    def enter(self):
+        GL.glPushAttrib(GL.GL_POLYGON_BIT)
+        GL.glPolygonOffset(self.sceneNode.depthOffset, self.sceneNode.depthOffset)
+        GL.glEnable(GL.GL_POLYGON_OFFSET_FILL)
+
+    def exit(self):
+        GL.glPopAttrib()
+
+
+class DepthOffsetNode(Node):
+    RenderNodeClass = DepthOffsetRenderNode
+
+    def __init__(self, depthOffset):
+        super(DepthOffsetNode, self).__init__()
+        self.depthOffset = depthOffset

src/mcedit2/rendering/scenegraph/matrix.py

@@ -0,0 +1,174 @@
+"""
+    matrix
+"""
+from __future__ import absolute_import, division, print_function, unicode_literals
+import logging
+from OpenGL import GL
+from mcedit2.rendering.scenegraph.rendernode import RenderstateRenderNode
+from mcedit2.rendering.scenegraph.scenenode import Node
+
+log = logging.getLogger(__name__)
+
+
+class RotateRenderNode(RenderstateRenderNode):
+    def __init__(self, sceneNode):
+        """
+
+        :type sceneNode: TranslateNode
+        """
+        super(RotateRenderNode, self).__init__(sceneNode)
+
+    def __repr__(self):
+        return "RotateRenderNode(%s, %s)" % (self.sceneNode.degrees, self.sceneNode.axis)
+
+    def enter(self):
+        GL.glMatrixMode(GL.GL_MODELVIEW)
+        GL.glPushMatrix()
+        GL.glRotate(self.sceneNode.degrees, *self.sceneNode.axis)
+
+    def exit(self):
+        GL.glMatrixMode(GL.GL_MODELVIEW)
+        GL.glPopMatrix()
+
+
+class RotateNode(Node):
+    RenderNodeClass = RotateRenderNode
+
+    def __init__(self, degrees, axis):
+        super(RotateNode, self).__init__()
+        self.degrees = degrees
+        self.axis = axis
+
+
+class TranslateRenderNode(RenderstateRenderNode):
+    def __init__(self, sceneNode):
+        """
+
+        :type sceneNode: TranslateNode
+        """
+        super(TranslateRenderNode, self).__init__(sceneNode)
+
+    def __repr__(self):
+        return "TranslateRenderNode(%s)" % (self.sceneNode.translateOffset,)
+
+    def enter(self):
+        GL.glMatrixMode(GL.GL_MODELVIEW)
+        GL.glPushMatrix()
+        GL.glTranslate(*self.sceneNode.translateOffset)
+
+    def exit(self):
+        GL.glMatrixMode(GL.GL_MODELVIEW)
+        GL.glPopMatrix()
+
+
+class TranslateNode(Node):
+    RenderNodeClass = TranslateRenderNode
+
+    def __init__(self, translateOffset=(0., 0., 0.)):
+        super(TranslateNode, self).__init__()
+        self._translateOffset = translateOffset
+
+    @property
+    def translateOffset(self):
+        return self._translateOffset
+
+    @translateOffset.setter
+    def translateOffset(self, value):
+        self._translateOffset = value
+        self.dirty = True
+
+
+class MatrixRenderNode(RenderstateRenderNode):
+    def enter(self):
+        projection = self.sceneNode.projection
+        if projection is not None:
+            GL.glMatrixMode(GL.GL_PROJECTION)
+            GL.glPushMatrix()
+            GL.glLoadMatrixd(projection.data())
+
+        modelview = self.sceneNode.modelview
+        if modelview is not None:
+            GL.glMatrixMode(GL.GL_MODELVIEW)
+            GL.glPushMatrix()
+            GL.glLoadMatrixd(modelview.data())
+
+    def exit(self):
+        if self.sceneNode.projection is not None:
+            GL.glMatrixMode(GL.GL_PROJECTION)
+            GL.glPopMatrix()
+        if self.sceneNode.modelview is not None:
+            GL.glMatrixMode(GL.GL_MODELVIEW)
+            GL.glPopMatrix()
+
+
+class MatrixNode(Node):
+    RenderNodeClass = MatrixRenderNode
+
+    _projection = None
+
+    @property
+    def projection(self):
+        """
+
+        :return:
+        :rtype: QMatrix4x4
+        """
+        return self._projection
+
+    @projection.setter
+    def projection(self, value):
+        """
+
+        :type value: QMatrix4x4
+        """
+        self._projection = value
+        self.dirty = True
+
+    _modelview = None
+    @property
+    def modelview(self):
+        """
+
+        :return:
+        :rtype: QMatrix4x4
+        """
+        return self._modelview
+
+    @modelview.setter
+    def modelview(self, value):
+        """
+
+        :type value: QMatrix4x4
+        """
+        self._modelview = value
+        self.dirty = True
+
+
+class OrthoRenderNode(RenderstateRenderNode):
+    def enter(self):
+        w, h = self.sceneNode.size
+        GL.glMatrixMode(GL.GL_PROJECTION)
+        GL.glPushMatrix()
+        GL.glLoadIdentity()
+        GL.glOrtho(0., w, 0., h, -200, 200)
+
+    def exit(self):
+        GL.glMatrixMode(GL.GL_PROJECTION)
+        GL.glPopMatrix()
+
+
+class OrthoNode(Node):
+    RenderNodeClass = OrthoRenderNode
+
+    def __init__(self, size=(1, 1)):
+        super(OrthoNode, self).__init__()
+        self._size = size
+
+    @property
+    def size(self):
+        return self._size
+
+    @size.setter
+    def size(self, value):
+        self._size = value
+        self.dirty = True

src/mcedit2/rendering/scenegraph/misc.py

@@ -0,0 +1,46 @@
+"""
+    misc
+"""
+from __future__ import absolute_import, division, print_function, unicode_literals
+import logging
+from OpenGL import GL
+from mcedit2.rendering.scenegraph.rendernode import RenderstateRenderNode, RenderNode
+from mcedit2.rendering.scenegraph.scenenode import Node
+
+log = logging.getLogger(__name__)
+
+
+class PolygonModeRenderNode(RenderstateRenderNode):
+    def enter(self):
+        GL.glPushAttrib(GL.GL_POLYGON_BIT)
+        GL.glPolygonMode(self.sceneNode.face, self.sceneNode.mode)
+
+    def exit(self):
+        GL.glPopAttrib()
+
+
+class PolygonModeNode(Node):
+    RenderNodeClass = PolygonModeRenderNode
+
+    def __init__(self, face, mode):
+        super(PolygonModeNode, self).__init__()
+        self.face = face
+        self.mode = mode
+
+
+class ClearRenderNode(RenderNode):
+    def drawSelf(self):
+        color = self.sceneNode.clearColor
+        if color is None:
+            GL.glClear(GL.GL_DEPTH_BUFFER_BIT)
+        else:
+            GL.glClearColor(*color)
+            GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
+
+
+class ClearNode(Node):
+    RenderNodeClass = ClearRenderNode
+
+    def __init__(self, clearColor=(0, 0, 0, 1)):
+        super(ClearNode, self).__init__()
+        self.clearColor = clearColor

src/mcedit2/rendering/scenegraph/rendernode.py

@@ -4,13 +4,14 @@
 from __future__ import absolute_import, division, print_function
 import logging
 import weakref
+
 from OpenGL import GL
 import numpy
+
 from mcedit2.rendering import cubes
 from mcedit2.rendering.depths import DepthOffset
 from mcedit2.util import profiler
-from mcedit2.util import glutils
-from mcedit2.util.glutils import DisplayList, gl
+from mcedit2.util.glutils import DisplayList
 
 log = logging.getLogger(__name__)
 
@@ -129,234 +130,8 @@ class RenderstateRenderNode(RenderNode):
     def exit(self):
         raise NotImplementedError
 
-class BindTextureRenderNode(RenderstateRenderNode):
-    def enter(self):
-        GL.glPushAttrib(GL.GL_ENABLE_BIT | GL.GL_TEXTURE_BIT)
-        GL.glMatrixMode(GL.GL_TEXTURE)
-        GL.glPushMatrix()
-        GL.glLoadIdentity()
-        scale = self.sceneNode.scale
-        if scale is not None:
-            GL.glScale(*scale)
-        glutils.glActiveTexture(GL.GL_TEXTURE0)
-        GL.glEnable(GL.GL_TEXTURE_2D)
-        self.sceneNode.texture.bind()
-
-    def exit(self):
-        GL.glMatrixMode(GL.GL_TEXTURE)
-        GL.glPopMatrix()
-        GL.glPopAttrib()
-
-
-
-class TextureAtlasRenderNode(RenderstateRenderNode):
-    def enter(self):
-        if self.sceneNode.textureAtlas is None:
-            return
-
-        GL.glColor(1., 1., 1., 1.)
-        textureAtlas = self.sceneNode.textureAtlas
-        glutils.glActiveTexture(GL.GL_TEXTURE0)
-        GL.glEnable(GL.GL_TEXTURE_2D)
-        textureAtlas.bindTerrain()
-
-        GL.glMatrixMode(GL.GL_TEXTURE)
-        GL.glPushMatrix()
-        GL.glLoadIdentity()
-        GL.glScale(1. / textureAtlas.width, 1. / textureAtlas.height, 1.)
-
-        glutils.glActiveTexture(GL.GL_TEXTURE1)
-        GL.glEnable(GL.GL_TEXTURE_2D)
-        textureAtlas.bindLight()
-
-        GL.glMatrixMode(GL.GL_TEXTURE)
-        GL.glPushMatrix()
-        GL.glLoadIdentity()
-        GL.glScale(1. / 16, 1. / 16, 1.)
-
-        glutils.glActiveTexture(GL.GL_TEXTURE0)
-        GL.glEnable(GL.GL_CULL_FACE)
-
-    def exit(self):
-        if self.sceneNode.textureAtlas is None:
-            return
-
-        GL.glDisable(GL.GL_CULL_FACE)
-        glutils.glActiveTexture(GL.GL_TEXTURE1)
-        GL.glBindTexture(GL.GL_TEXTURE_2D, 0)
-        GL.glDisable(GL.GL_TEXTURE_2D)
-        GL.glMatrixMode(GL.GL_TEXTURE)
-        GL.glPopMatrix()
-
-        glutils.glActiveTexture(GL.GL_TEXTURE0)
-        GL.glDisable(GL.GL_TEXTURE_2D)
-        GL.glMatrixMode(GL.GL_TEXTURE)
-        GL.glPopMatrix()
-
-
-class TranslateRenderNode(RenderstateRenderNode):
-    def __init__(self, sceneNode):
-        """
-
-        :type sceneNode: TranslateNode
-        """
-        super(TranslateRenderNode, self).__init__(sceneNode)
-
-    def __repr__(self):
-        return "TranslateRenderNode(%s)" % (self.sceneNode.translateOffset,)
-
-    def enter(self):
-        GL.glMatrixMode(GL.GL_MODELVIEW)
-        GL.glPushMatrix()
-        GL.glTranslate(*self.sceneNode.translateOffset)
-
-    def exit(self):
-        GL.glMatrixMode(GL.GL_MODELVIEW)
-        GL.glPopMatrix()
-
-class RotateRenderNode(RenderstateRenderNode):
-    def __init__(self, sceneNode):
-        """
-
-        :type sceneNode: TranslateNode
-        """
-        super(RotateRenderNode, self).__init__(sceneNode)
-
-    def __repr__(self):
-        return "RotateRenderNode(%s, %s)" % (self.sceneNode.degrees,self.sceneNode.axis)
-
-    def enter(self):
-        GL.glMatrixMode(GL.GL_MODELVIEW)
-        GL.glPushMatrix()
-        GL.glRotate(self.sceneNode.degrees, *self.sceneNode.axis)
-
-    def exit(self):
-        GL.glMatrixMode(GL.GL_MODELVIEW)
-        GL.glPopMatrix()
-
-
-class PolygonModeRenderNode(RenderstateRenderNode):
-    def enter(self):
-        GL.glPushAttrib(GL.GL_POLYGON_BIT)
-        GL.glPolygonMode(self.sceneNode.face, self.sceneNode.mode)
-
-    def exit(self):
-        GL.glPopAttrib()
-
-
-class VertexRenderNode(RenderNode):
-    def __init__(self, sceneNode):
-        """
-
-        :type sceneNode: VertexNode
-        """
-        super(VertexRenderNode, self).__init__(sceneNode)
-
-        self.didDraw = False
-
-    def invalidate(self):
-        if self.didDraw:
-            assert False
-        super(VertexRenderNode, self).invalidate()
-
-
-    def drawSelf(self):
-        self.didDraw = True
-        bare = []
-        withTex = []
-        withLights = []
-        for array in self.sceneNode.vertexArrays:
-            if array.lights:
-                withLights.append(array)
-            elif array.textures:
-                withTex.append(array)
-            else:
-                bare.append(array)
-
-        with gl.glPushAttrib(GL.GL_ENABLE_BIT):
-            GL.glDisable(GL.GL_TEXTURE_2D)
-            self.drawArrays(bare, False, False)
-            GL.glEnable(GL.GL_TEXTURE_2D)
-            self.drawArrays(withTex, True, False)
-            self.drawArrays(withLights, True, True)
-
-    def drawArrays(self, vertexArrays, textures, lights):
-        if textures:
-            GL.glClientActiveTexture(GL.GL_TEXTURE0)
-            GL.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY)
-        if lights:
-            GL.glClientActiveTexture(GL.GL_TEXTURE1)
-            GL.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY)
-        else:
-            GL.glMultiTexCoord2d(GL.GL_TEXTURE1, 15, 15)
-
-        GL.glEnableClientState(GL.GL_COLOR_ARRAY)
-
-        for array in vertexArrays:
-            if 0 == len(array.buffer):
-                continue
-            stride = 4 * array.elements
-
-            buf = array.buffer.ravel()
-
-            GL.glVertexPointer(3, GL.GL_FLOAT, stride, buf)
-            if textures:
-                GL.glClientActiveTexture(GL.GL_TEXTURE0)
-                GL.glTexCoordPointer(2, GL.GL_FLOAT, stride, (buf[array.texOffset:]))
-            if lights:
-                GL.glClientActiveTexture(GL.GL_TEXTURE1)
-                GL.glTexCoordPointer(2, GL.GL_FLOAT, stride, (buf[array.lightOffset:]))
-            GL.glColorPointer(4, GL.GL_UNSIGNED_BYTE, stride, (buf.view(dtype=numpy.uint8)[array.rgbaOffset*4:]))
-
-            vertexCount = int(array.buffer.size / array.elements)
-            GL.glDrawArrays(array.gl_type, 0, vertexCount)
-
-        GL.glDisableClientState(GL.GL_COLOR_ARRAY)
-
-        if lights:
-            GL.glDisableClientState(GL.GL_TEXTURE_COORD_ARRAY)
-
-        if textures:
-            GL.glClientActiveTexture(GL.GL_TEXTURE0)
-            GL.glDisableClientState(GL.GL_TEXTURE_COORD_ARRAY)
-
-class OrthoRenderNode(RenderstateRenderNode):
-    def enter(self):
-        w, h = self.sceneNode.size
-        GL.glMatrixMode(GL.GL_PROJECTION)
-        GL.glPushMatrix()
-        GL.glLoadIdentity()
-        GL.glOrtho(0., w, 0., h, -200, 200)
-
-    def exit(self):
-        GL.glMatrixMode(GL.GL_PROJECTION)
-        GL.glPopMatrix()
-
-
-class ClearRenderNode(RenderNode):
-    def drawSelf(self):
-        color = self.sceneNode.clearColor
-        if color is None:
-            GL.glClear(GL.GL_DEPTH_BUFFER_BIT)
-        else:
-            GL.glClearColor(*color)
-            GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
-
-class DepthMaskRenderNode(RenderstateRenderNode):
-    def enter(self):
-        GL.glPushAttrib(GL.GL_DEPTH_BUFFER_BIT)
-        GL.glDepthMask(self.sceneNode.mask)
-
-    def exit(self):
-        GL.glPopAttrib()
-
-class DepthFuncRenderNode(RenderstateRenderNode):
-    def enter(self):
-        GL.glPushAttrib(GL.GL_DEPTH_BUFFER_BIT)
-        GL.glDepthFunc(self.sceneNode.func)
-
-    def exit(self):
-        GL.glPopAttrib()
+"""
+UNUSED??
 
 class BoxRenderNode(RenderNode):
     def drawSelf(self):
@@ -375,16 +150,7 @@ class BoxFaceRenderNode(RenderNode):
         GL.glLineWidth(2.0)
         cubes.drawFace(box, face, elementType=GL.GL_LINE_STRIP)
         GL.glDisable(GL.GL_BLEND)
-
-
-class DepthOffsetRenderNode(RenderstateRenderNode):
-    def enter(self):
-        GL.glPushAttrib(GL.GL_POLYGON_BIT)
-        GL.glPolygonOffset(self.sceneNode.depthOffset, self.sceneNode.depthOffset)
-        GL.glEnable(GL.GL_POLYGON_OFFSET_FILL)
-
-    def exit(self):
-        GL.glPopAttrib()
+"""
 
 def updateRenderNode(renderNode):
     """

src/mcedit2/rendering/scenegraph/scenenode.py

@@ -9,7 +9,6 @@ from mcedit2.rendering.scenegraph import rendernode
 
 log = logging.getLogger(__name__)
 
-from OpenGL import GL
 
 class Node(object):
     RenderNodeClass = rendernode.RenderNode
@@ -146,183 +145,3 @@ class RenderstateNode(Node):
                                                                            self.visible, len(self._children))
 
 
-class TextureAtlasNode(Node):
-    RenderNodeClass = rendernode.TextureAtlasRenderNode
-
-    def __init__(self, textureAtlas=None):
-        super(TextureAtlasNode, self).__init__()
-        self.textureAtlas = textureAtlas
-
-    @property
-    def textureAtlas(self):
-        return self._textureAtlas
-
-    @textureAtlas.setter
-    def textureAtlas(self, value):
-        self._textureAtlas = value
-        self.dirty = True
-
-class TranslateNode(Node):
-    RenderNodeClass = rendernode.TranslateRenderNode
-
-    def __init__(self, translateOffset=(0., 0., 0.)):
-        super(TranslateNode, self).__init__()
-        self._translateOffset = translateOffset
-
-    @property
-    def translateOffset(self):
-        return self._translateOffset
-
-    @translateOffset.setter
-    def translateOffset(self, value):
-        self._translateOffset = value
-        self.dirty = True
-
-class RotateNode(Node):
-    RenderNodeClass = rendernode.RotateRenderNode
-
-    def __init__(self, degrees, axis):
-        super(RotateNode, self).__init__()
-        self.degrees = degrees
-        self.axis = axis
-
-
-
-class DepthMaskNode(Node):
-    RenderNodeClass = rendernode.DepthMaskRenderNode
-    mask = False
-
-
-class DepthFuncNode(Node):
-    RenderNodeClass = rendernode.DepthFuncRenderNode
-
-    def __init__(self, func=GL.GL_LESS):
-        super(DepthFuncNode, self).__init__()
-        self.func = func
-
-class ClearNode(Node):
-    RenderNodeClass = rendernode.ClearRenderNode
-
-    def __init__(self, clearColor=(0, 0, 0, 1)):
-        super(ClearNode, self).__init__()
-        self.clearColor = clearColor
-
-class OrthoNode(Node):
-    RenderNodeClass = rendernode.OrthoRenderNode
-
-    def __init__(self, size=(1, 1)):
-        super(OrthoNode, self).__init__()
-        self._size = size
-
-    @property
-    def size(self):
-        return self._size
-
-    @size.setter
-    def size(self, value):
-        self._size = value
-        self.dirty = True
-
-class PolygonModeNode(Node):
-    RenderNodeClass = rendernode.PolygonModeRenderNode
-    def __init__(self, face, mode):
-        super(PolygonModeNode, self).__init__()
-        self.face = face
-        self.mode = mode
-
-
-class VertexNode(Node):
-    RenderNodeClass = rendernode.VertexRenderNode
-
-    def __init__(self, vertexArrays):
-        """
-
-        :type vertexArrays: list[VertexArrayBuffer]
-        """
-        super(VertexNode, self).__init__()
-        if not isinstance(vertexArrays, (list, tuple)):
-            vertexArrays = [vertexArrays]
-        self.vertexArrays = vertexArrays
-
-class BindTextureNode(Node):
-    RenderNodeClass = rendernode.BindTextureRenderNode
-
-    def __init__(self, texture, scale=None):
-        """
-
-        :type texture: glutils.Texture
-        """
-        super(BindTextureNode, self).__init__()
-        self.texture = texture
-        self.scale = scale
-        # changing texture not implemented
-
-class MatrixRenderNode(rendernode.RenderstateRenderNode):
-    def enter(self):
-        projection = self.sceneNode.projection
-        if projection is not None:
-            GL.glMatrixMode(GL.GL_PROJECTION)
-            GL.glPushMatrix()
-            GL.glLoadMatrixd(projection.data())
-
-        modelview = self.sceneNode.modelview
-        if modelview is not None:
-            GL.glMatrixMode(GL.GL_MODELVIEW)
-            GL.glPushMatrix()
-            GL.glLoadMatrixd(modelview.data())
-
-    def exit(self):
-        if self.sceneNode.projection is not None:
-            GL.glMatrixMode(GL.GL_PROJECTION)
-            GL.glPopMatrix()
-        if self.sceneNode.modelview is not None:
-            GL.glMatrixMode(GL.GL_MODELVIEW)
-            GL.glPopMatrix()
-
-
-class MatrixNode(Node):
-    RenderNodeClass = MatrixRenderNode
-
-    _projection = None
-    @property
-    def projection(self):
-        """
-
-        :return:
-        :rtype: QMatrix4x4
-        """
-        return self._projection
-
-    @projection.setter
-    def projection(self, value):
-        """
-
-        :type value: QMatrix4x4
-        """
-        self._projection = value
-        self.dirty = True
-
-    _modelview = None
-    @property
-    def modelview(self):
-        """
-
-        :return:
-        :rtype: QMatrix4x4
-        """
-        return self._modelview
-
-    @modelview.setter
-    def modelview(self, value):
-        """
-
-        :type value: QMatrix4x4
-        """
-        self._modelview = value
-        self.dirty = True
-
-class DepthOffsetNode(Node):
-    RenderNodeClass = rendernode.DepthOffsetRenderNode
-    def __init__(self, depthOffset):
-        super(DepthOffsetNode, self).__init__()
-        self.depthOffset = depthOffset

src/mcedit2/rendering/scenegraph/texture_atlas.py

@@ -0,0 +1,74 @@
+"""
+    texture_atlas
+"""
+from __future__ import absolute_import, division, print_function, unicode_literals
+import logging
+from OpenGL import GL
+
+from mcedit2.rendering.scenegraph.rendernode import RenderstateRenderNode
+from mcedit2.rendering.scenegraph.scenenode import Node
+from mcedit2.util import glutils
+
+log = logging.getLogger(__name__)
+
+
+class TextureAtlasRenderNode(RenderstateRenderNode):
+    def enter(self):
+        if self.sceneNode.textureAtlas is None:
+            return
+
+        GL.glColor(1., 1., 1., 1.)
+        textureAtlas = self.sceneNode.textureAtlas
+        glutils.glActiveTexture(GL.GL_TEXTURE0)
+        GL.glEnable(GL.GL_TEXTURE_2D)
+        textureAtlas.bindTerrain()
+
+        GL.glMatrixMode(GL.GL_TEXTURE)
+        GL.glPushMatrix()
+        GL.glLoadIdentity()
+        GL.glScale(1. / textureAtlas.width, 1. / textureAtlas.height, 1.)
+
+        glutils.glActiveTexture(GL.GL_TEXTURE1)
+        GL.glEnable(GL.GL_TEXTURE_2D)
+        textureAtlas.bindLight()
+
+        GL.glMatrixMode(GL.GL_TEXTURE)
+        GL.glPushMatrix()
+        GL.glLoadIdentity()
+        GL.glScale(1. / 16, 1. / 16, 1.)
+
+        glutils.glActiveTexture(GL.GL_TEXTURE0)
+        GL.glEnable(GL.GL_CULL_FACE)
+
+    def exit(self):
+        if self.sceneNode.textureAtlas is None:
+            return
+
+        GL.glDisable(GL.GL_CULL_FACE)
+        glutils.glActiveTexture(GL.GL_TEXTURE1)
+        GL.glBindTexture(GL.GL_TEXTURE_2D, 0)
+        GL.glDisable(GL.GL_TEXTURE_2D)
+        GL.glMatrixMode(GL.GL_TEXTURE)
+        GL.glPopMatrix()
+
+        glutils.glActiveTexture(GL.GL_TEXTURE0)
+        GL.glDisable(GL.GL_TEXTURE_2D)
+        GL.glMatrixMode(GL.GL_TEXTURE)
+        GL.glPopMatrix()
+
+
+class TextureAtlasNode(Node):
+    RenderNodeClass = TextureAtlasRenderNode
+
+    def __init__(self, textureAtlas=None):
+        super(TextureAtlasNode, self).__init__()
+        self.textureAtlas = textureAtlas
+
+    @property
+    def textureAtlas(self):
+        return self._textureAtlas
+
+    @textureAtlas.setter
+    def textureAtlas(self, value):
+        self._textureAtlas = value
+        self.dirty = True

src/mcedit2/rendering/scenegraph/vertex_array.py

@@ -0,0 +1,104 @@
+"""
+    vertex_array
+"""
+from __future__ import absolute_import, division, print_function, unicode_literals
+import logging
+
+from OpenGL import GL
+import numpy
+
+from mcedit2.rendering.scenegraph.rendernode import RenderNode
+from mcedit2.rendering.scenegraph.scenenode import Node
+from mcedit2.util.glutils import gl
+
+log = logging.getLogger(__name__)
+
+
+class VertexRenderNode(RenderNode):
+    def __init__(self, sceneNode):
+        """
+
+        :type sceneNode: VertexNode
+        """
+        super(VertexRenderNode, self).__init__(sceneNode)
+
+        self.didDraw = False
+
+    def invalidate(self):
+        if self.didDraw:
+            assert False
+        super(VertexRenderNode, self).invalidate()
+
+    def drawSelf(self):
+        self.didDraw = True
+        bare = []
+        withTex = []
+        withLights = []
+        for array in self.sceneNode.vertexArrays:
+            if array.lights:
+                withLights.append(array)
+            elif array.textures:
+                withTex.append(array)
+            else:
+                bare.append(array)
+
+        with gl.glPushAttrib(GL.GL_ENABLE_BIT):
+            GL.glDisable(GL.GL_TEXTURE_2D)
+            self.drawArrays(bare, False, False)
+            GL.glEnable(GL.GL_TEXTURE_2D)
+            self.drawArrays(withTex, True, False)
+            self.drawArrays(withLights, True, True)
+
+    def drawArrays(self, vertexArrays, textures, lights):
+        if textures:
+            GL.glClientActiveTexture(GL.GL_TEXTURE0)
+            GL.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY)
+        if lights:
+            GL.glClientActiveTexture(GL.GL_TEXTURE1)
+            GL.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY)
+        else:
+            GL.glMultiTexCoord2d(GL.GL_TEXTURE1, 15, 15)
+
+        GL.glEnableClientState(GL.GL_COLOR_ARRAY)
+
+        for array in vertexArrays:
+            if 0 == len(array.buffer):
+                continue
+            stride = 4 * array.elements
+
+            buf = array.buffer.ravel()
+
+            GL.glVertexPointer(3, GL.GL_FLOAT, stride, buf)
+            if textures:
+                GL.glClientActiveTexture(GL.GL_TEXTURE0)
+                GL.glTexCoordPointer(2, GL.GL_FLOAT, stride, (buf[array.texOffset:]))
+            if lights:
+                GL.glClientActiveTexture(GL.GL_TEXTURE1)
+                GL.glTexCoordPointer(2, GL.GL_FLOAT, stride, (buf[array.lightOffset:]))
+            GL.glColorPointer(4, GL.GL_UNSIGNED_BYTE, stride, (buf.view(dtype=numpy.uint8)[array.rgbaOffset*4:]))
+
+            vertexCount = int(array.buffer.size / array.elements)
+            GL.glDrawArrays(array.gl_type, 0, vertexCount)
+
+        GL.glDisableClientState(GL.GL_COLOR_ARRAY)
+
+        if lights:
+            GL.glDisableClientState(GL.GL_TEXTURE_COORD_ARRAY)
+
+        if textures:
+            GL.glClientActiveTexture(GL.GL_TEXTURE0)
+            GL.glDisableClientState(GL.GL_TEXTURE_COORD_ARRAY)
+
+
+class VertexNode(Node):
+    RenderNodeClass = VertexRenderNode
+
+    def __init__(self, vertexArrays):
+        """
+
+        :type vertexArrays: list[VertexArrayBuffer]
+        """
+        super(VertexNode, self).__init__()
+        if not isinstance(vertexArrays, (list, tuple)):
+            vertexArrays = [vertexArrays]
+        self.vertexArrays = vertexArrays

src/mcedit2/rendering/selection.py

@@ -14,7 +14,8 @@ from mcedit2.rendering.scenegraph import scenenode, rendernode
 from mcedit2.rendering.chunknode import ChunkGroupNode, ChunkNode
 from mcedit2.rendering.depths import DepthOffset
 from mcedit2.rendering.renderstates import _RenderstateAlphaBlendNode
-from mcedit2.rendering.scenegraph.scenenode import VertexNode, RenderstateNode
+from mcedit2.rendering.scenegraph.scenenode import RenderstateNode
+from mcedit2.rendering.scenegraph.vertex_array import VertexNode
 from mcedit2.rendering.vertexarraybuffer import QuadVertexArrayBuffer
 from mcedit2.util import profiler
 from mcedit2.util.glutils import gl

src/mcedit2/rendering/workplane.py

@@ -7,6 +7,8 @@ import logging
 from OpenGL import GL
 
 from mcedit2.rendering.scenegraph import scenenode
+import mcedit2.rendering.scenegraph.matrix
+import mcedit2.rendering.scenegraph.vertex_array
 from mcedit2.rendering.vertexarraybuffer import VertexArrayBuffer
 
 log = logging.getLogger(__name__)
@@ -17,7 +19,7 @@ class WorkplaneNode(scenenode.Node):
 
     def __init__(self):
         super(WorkplaneNode, self).__init__()
-        self.translateNode = scenenode.TranslateNode()
+        self.translateNode = mcedit2.rendering.scenegraph.matrix.TranslateNode()
         self.addChild(self.translateNode)
         self.axis = 1
 
@@ -67,7 +69,7 @@ class WorkplaneNode(scenenode.Node):
 
         if self.vertexNode:
             self.translateNode.removeChild(self.vertexNode)
-        self.vertexNode = scenenode.VertexNode([gridArrayBuffer])
+        self.vertexNode = mcedit2.rendering.scenegraph.vertex_array.VertexNode([gridArrayBuffer])
         self.translateNode.addChild(self.vertexNode)
 
     @property

src/mcedit2/rendering/worldscene.py

@@ -18,6 +18,8 @@ from mcedit2.rendering.chunknode import ChunkNode, ChunkGroupNode
 from mcedit2.rendering.chunkupdate import ChunkRenderInfo
 from mcedit2.rendering.depths import DepthOffset
 from mcedit2.rendering.geometrycache import GeometryCache
+import mcedit2.rendering.scenegraph.depth_test
+import mcedit2.rendering.scenegraph.texture_atlas
 from mcedit2.util.glutils import Texture
 from mcedit2.util.load_png import loadPNGData
 from mceditlib.anvil.biome_types import BiomeTypes
@@ -207,10 +209,10 @@ class WorldScene(scenenode.Node):
 
         self.dimension = dimension
         self.textureAtlas = textureAtlas
-        self.depthOffsetNode = scenenode.DepthOffsetNode(DepthOffset.Renderer)
+        self.depthOffsetNode = mcedit2.rendering.scenegraph.depth_test.DepthOffsetNode(DepthOffset.Renderer)
         self.addChild(self.depthOffsetNode)
 
-        self.textureAtlasNode = scenenode.TextureAtlasNode(textureAtlas)
+        self.textureAtlasNode = mcedit2.rendering.scenegraph.texture_atlas.TextureAtlasNode(textureAtlas)
         self.depthOffsetNode.addChild(self.textureAtlasNode)
 
         self.renderstateNodes = {}

src/mcedit2/synth/l_system.py

@@ -6,7 +6,7 @@ import logging
 
 from OpenGL import GL
 
-from mcedit2.rendering.scenegraph.scenenode import VertexNode
+from mcedit2.rendering.scenegraph.vertex_array import VertexNode
 from mcedit2.rendering.selection import SelectionBoxNode
 from mcedit2.rendering.vertexarraybuffer import VertexArrayBuffer
 from mcedit2.util import bresenham

src/mcedit2/worldview/worldview.py

@@ -20,6 +20,9 @@ from mcedit2.rendering.chunknode import ChunkNode
 from mcedit2.rendering.frustum import Frustum
 from mcedit2.rendering.geometrycache import GeometryCache
 from mcedit2.rendering.layers import Layer
+import mcedit2.rendering.scenegraph.matrix
+import mcedit2.rendering.scenegraph.misc
+import mcedit2.rendering.scenegraph.vertex_array
 from mcedit2.rendering.textureatlas import TextureAtlas
 from mcedit2.rendering.vertexarraybuffer import VertexArrayBuffer
 from mcedit2.rendering.scenegraph import scenenode, rendernode
@@ -45,7 +48,8 @@ def worldMeshVertexSize(worldMesh):
         for cm in worldMesh.chunkGroupNode.children:
             assert isinstance(cm, ChunkNode)
             for bm in cm.getChunkVertexNodes():
-                assert isinstance(bm, scenenode.VertexNode)
+                assert isinstance(bm,
+                                  mcedit2.rendering.scenegraph.vertex_array.VertexNode)
                 for va in bm.vertexArrays:
                     assert isinstance(va, VertexArrayBuffer)
                     yield va.buffer.nbytes
@@ -117,7 +121,7 @@ class WorldView(QGLWidget):
         self.autoUpdateInterval = 0.5  # frequency of screen redraws in response to loaded chunks
 
         self.compassNode = self.createCompass()
-        self.compassOrthoNode = scenenode.OrthoNode((1, float(self.height()) / self.width()))
+        self.compassOrthoNode = mcedit2.rendering.scenegraph.matrix.OrthoNode((1, float(self.height()) / self.width()))
         self.compassOrthoNode.addChild(self.compassNode)
 
         self.viewActions = []
@@ -219,11 +223,11 @@ class WorldView(QGLWidget):
         self.worldScene = self.createWorldScene()
         self.worldScene.setVisibleLayers(self.layerToggleGroup.getVisibleLayers())
 
-        clearNode = scenenode.ClearNode()
+        clearNode = mcedit2.rendering.scenegraph.misc.ClearNode()
         skyNode = sky.SkyNode()
         self.loadableChunksNode = loadablechunks.LoadableChunksNode(self.dimension)
 
-        self.matrixNode = scenenode.MatrixNode()
+        self.matrixNode = mcedit2.rendering.scenegraph.matrix.MatrixNode()
         self._updateMatrices()
 
         self.matrixNode.addChild(self.loadableChunksNode)

src/plugins/hilbert.py

@@ -10,7 +10,7 @@ from OpenGL import GL
 from PySide import QtGui
 
 from mcedit2.plugins import registerGeneratePlugin
-from mcedit2.rendering.scenegraph.scenenode import VertexNode
+from mcedit2.rendering.scenegraph.vertex_array import VertexNode
 from mcedit2.rendering.vertexarraybuffer import VertexArrayBuffer
 from mcedit2.synth.l_system import Geometric, Symbol
 from mcedit2.synth.l_system_plugin import LSystemPlugin