def displaySchematic(schematic):
global _swv_app
if QtGui.qApp is None:
_swv_app = QtGui.QApplication([])
if hasattr(schematic, 'getDimension'):
dim = schematic.getDimension()
else:
dim = schematic
resourceLoader = minecraftinstall.getSelectedResourceLoader() # xxx select using dim.blocktypes
blockModels = BlockModels(schematic.blocktypes, resourceLoader)
textureAtlas = TextureAtlas(schematic, resourceLoader, blockModels)
_swv_view = SchematicWorldView(dim, textureAtlas)
loader = WorldLoader(_swv_view.worldScene)
loader.timer.timeout.connect(_swv_view.update)
loader.startLoader()
centerWidgetInScreen(_swv_view, resize=0.75)
_swv_view.show()
_swv_app.exec_()
class GenerateTool(EditorTool):
name = "Generate"
iconName = "generate"
instantDisplayChunks = 32
modifiesWorld = True
def __init__(self, *args, **kwargs):
EditorTool.__init__(self, *args, **kwargs)
self.livePreview = False
self.blockPreview = False
self.glPreview = True
toolWidget = QtGui.QWidget()
self.toolWidget = toolWidget
column = []
self.generatorTypes = [
pluginClass(self)
for pluginClass in GeneratePlugins.registeredPlugins
]
self.currentGenerator = None
if len(self.generatorTypes):
self.currentGenerator = self.generatorTypes[0]
self.generatorTypeInput = QtGui.QComboBox()
self.generatorTypesChanged()
self.generatorTypeInput.currentIndexChanged.connect(
self.currentTypeChanged)
self.livePreviewCheckbox = QtGui.QCheckBox("Live Preview")
self.livePreviewCheckbox.setChecked(self.livePreview)
self.livePreviewCheckbox.toggled.connect(self.livePreviewToggled)
self.blockPreviewCheckbox = QtGui.QCheckBox("Block Preview")
self.blockPreviewCheckbox.setChecked(self.blockPreview)
self.blockPreviewCheckbox.toggled.connect(self.blockPreviewToggled)
self.glPreviewCheckbox = QtGui.QCheckBox("GL Preview")
self.glPreviewCheckbox.setChecked(self.glPreview)
self.glPreviewCheckbox.toggled.connect(self.glPreviewToggled)
self.optionsHolder = QtGui.QStackedWidget()
self.optionsHolder.setSizePolicy(QtGui.QSizePolicy.Preferred,
QtGui.QSizePolicy.Expanding)
self.generateButton = QtGui.QPushButton(self.tr("Generate"))
self.generateButton.clicked.connect(self.generateClicked)
column.append(self.generatorTypeInput)
column.append(self.livePreviewCheckbox)
column.append(self.blockPreviewCheckbox)
column.append(self.glPreviewCheckbox)
column.append(self.optionsHolder)
column.append(self.generateButton)
self.toolWidget.setLayout(Column(*column))
self.overlayNode = scenenode.Node("generateOverlay")
self.sceneHolderNode = Node("sceneHolder")
self.sceneTranslate = Translate()
self.sceneHolderNode.addState(self.sceneTranslate)
self.overlayNode.addChild(self.sceneHolderNode)
self.previewNode = None
self.boxHandleNode = BoxHandle()
self.boxHandleNode.boundsChanged.connect(self.boundsDidChange)
self.boxHandleNode.boundsChangedDone.connect(self.boundsDidChangeDone)
self.overlayNode.addChild(self.boxHandleNode)
self.worldScene = None
self.loader = None
self.previewBounds = None
self.schematicBounds = None
self.currentSchematic = None
self.currentTypeChanged(0)
# Name of last selected generator plugin is saved after unloading
# so it can be reselected if it is immediately reloaded
self._lastTypeName = None
GeneratePlugins.pluginAdded.connect(self.addPlugin)
GeneratePlugins.pluginRemoved.connect(self.removePlugin)
def removePlugin(self, cls):
log.info("Removing plugin %s", cls.__name__)
self.generatorTypes[:] = [
gt for gt in self.generatorTypes if not isinstance(gt, cls)
]
self.generatorTypesChanged()
if self.currentGenerator not in self.generatorTypes:
lastTypeName = self.currentGenerator.__class__.__name__
self.currentTypeChanged(0) # resets self._lastTypeName
self._lastTypeName = lastTypeName
def addPlugin(self, cls):
log.info("Adding plugin %s", cls.__name__)
self.generatorTypes.append(cls(self))
self.generatorTypesChanged()
if self._lastTypeName is not None:
if cls.__name__ == self._lastTypeName:
self.currentTypeChanged(len(self.generatorTypes) - 1)
def generatorTypesChanged(self):
self.generatorTypeInput.clear()
for gt in self.generatorTypes:
if hasattr(gt, 'displayName'):
displayName = gt.displayName
else:
displayName = gt.__class__.__name__
self.generatorTypeInput.addItem(displayName, gt)
def livePreviewToggled(self, value):
self.livePreview = value
def blockPreviewToggled(self, value):
self.blockPreview = value
if value:
if self.currentSchematic:
self.displaySchematic(self.currentSchematic,
self.schematicBounds.origin)
else:
self.updateBlockPreview()
else:
self.clearSchematic()
def glPreviewToggled(self, value):
self.glPreview = value
if value:
self.updateNodePreview() # xxx cache previewNode?
else:
self.clearNode()
def currentTypeChanged(self, index):
# user selected generator type after old type was unloaded, so forget the old type
self._lastTypeName = None
self.optionsHolder.removeWidget(self.optionsHolder.widget(0))
if index < len(self.generatorTypes):
self.currentGenerator = self.generatorTypes[index]
self.optionsHolder.addWidget(
self.currentGenerator.getOptionsWidget())
self.updatePreview()
else:
self.currentGenerator = None
self.clearSchematic()
self.clearNode()
log.info("Chose generator %s", repr(self.currentGenerator))
def mousePress(self, event):
self.boxHandleNode.mousePress(event)
def mouseMove(self, event):
self.boxHandleNode.mouseMove(event)
def mouseRelease(self, event):
self.boxHandleNode.mouseRelease(event)
def boundsDidChange(self, bounds):
# box still being resized
if not self.currentGenerator:
return
if not self.livePreview:
return
self.previewBounds = bounds
self.currentGenerator.boundsChanged(bounds)
self.updatePreview()
def boundsDidChangeDone(self, bounds, oldBounds):
# box finished resize
if not self.currentGenerator:
return
self.previewBounds = bounds
self.schematicBounds = bounds
self.currentGenerator.boundsChanged(bounds)
self.updatePreview()
def clearNode(self):
if self.previewNode:
self.overlayNode.removeChild(self.previewNode)
self.previewNode = None
def updatePreview(self):
if self.blockPreview:
self.updateBlockPreview()
else:
self.clearSchematic()
if self.glPreview:
self.updateNodePreview()
else:
self.clearNode()
def updateBlockPreview(self):
bounds = self.previewBounds
if bounds is not None and bounds.volume > 0:
self.generateNextSchematic(bounds)
else:
self.clearSchematic()
def updateNodePreview(self):
bounds = self.previewBounds
if self.currentGenerator is None:
return
if bounds is not None and bounds.volume > 0:
try:
node = self.currentGenerator.getPreviewNode(bounds)
except Exception:
log.exception(
"Error while getting scene nodes from generator:")
else:
if node is not None:
self.clearNode()
if isinstance(node, list):
nodes = node
node = scenenode.Node("generatePreviewHolder")
for c in nodes:
node.addChild(c)
self.overlayNode.addChild(node)
self.previewNode = node
def generateNextSchematic(self, bounds):
if bounds is None:
self.clearSchematic()
return
if self.currentGenerator is None:
return
try:
schematic = self.currentGenerator.generate(
bounds, self.editorSession.worldEditor.blocktypes)
self.currentSchematic = schematic
self.displaySchematic(schematic, bounds.origin)
except Exception as e:
log.exception("Error while running generator %s: %s",
self.currentGenerator, e)
QtGui.QMessageBox.warning(
QtGui.qApp.mainWindow, "Error while running generator",
"An error occurred while running the generator: \n %s.\n\n"
"Traceback: %s" % (e, traceback.format_exc()))
self.livePreview = False
def displaySchematic(self, schematic, offset):
if schematic is not None:
dim = schematic.getDimension()
if self.worldScene:
self.sceneHolderNode.removeChild(self.worldScene)
self.loader.timer.stop()
self.loader = None
atlas = self.editorSession.textureAtlas
self.worldScene = WorldScene(dim, atlas)
self.sceneTranslate.translateOffset = offset
self.sceneHolderNode.addChild(self.worldScene)
self.loader = WorldLoader(self.worldScene)
if dim.chunkCount() <= self.instantDisplayChunks:
exhaust(self.loader.work())
else:
self.loader.startLoader()
else:
self.clearSchematic()
def clearSchematic(self):
if self.worldScene:
self.sceneHolderNode.removeChild(self.worldScene)
self.worldScene = None
self.loader.timer.stop()
self.loader = None
def generateClicked(self):
if self.currentGenerator is None:
return
if self.schematicBounds is None:
log.info("schematicBounds is None, not generating")
return
if self.currentSchematic is None:
log.info("Generating new schematic for import")
currentSchematic = self.currentGenerator.generate(
self.schematicBounds,
self.editorSession.worldEditor.blocktypes)
else:
log.info("Importing previously generated schematic.")
currentSchematic = self.currentSchematic
command = GenerateCommand(self, self.schematicBounds)
try:
with command.begin():
if currentSchematic is not None:
task = self.editorSession.currentDimension.importSchematicIter(
currentSchematic, self.schematicBounds.origin)
showProgress(self.tr("Importing generated object..."),
task)
else:
task = self.currentGenerator.generateInWorld(
self.schematicBounds,
self.editorSession.currentDimension)
showProgress(self.tr("Generating object in world..."),
task)
except Exception as e:
log.exception("Error while importing or generating in world: %r" %
e)
command.undo()
else:
self.editorSession.pushCommand(command)
class PendingImportNode(Node, QtCore.QObject):
__node_id_counter = 0
def __init__(self, pendingImport, textureAtlas):
"""
A scenegraph node displaying an object that will be imported later, including
live and deferred views of the object with transformed items, and a BoxHandle
for moving the item.
Parameters
----------
pendingImport: PendingImport
The object to be imported. The PendingImportNode responds to changes in this
object's position, rotation, and scale.
textureAtlas: TextureAtlas
The textures and block models used to render the preview of the object.
Attributes
----------
basePosition: Vector
The pre-transform position of the pending import. This is equal to
`self.pendingImport.basePosition` except when the node is currently being
dragged.
transformedPosition: Vector
The post-transform position of the pending import. This is equal to
`self.pendingImport.importPos` except when the node is currently being
dragged, scaled, or rotated.
"""
super(PendingImportNode, self).__init__()
self.textureAtlas = textureAtlas
self.pendingImport = pendingImport
dim = pendingImport.sourceDim
# positionTranslateNode contains the non-transformed preview of the imported
# object, including its world scene. This preview will be rotated model-wise
# while the user is dragging the rotate controls.
self.positionTranslateNode = TranslateNode()
self.rotateNode = Rotate3DNode()
self.addChild(self.positionTranslateNode)
self.positionTranslateNode.addChild(self.rotateNode)
self.rotateNode.setAnchor(self.pendingImport.selection.size * 0.5)
# worldSceneTranslateNode is contained by positionTranslateNode, and
# serves to translate the world scene back to 0, 0, 0 so the positionTranslateNode
# can translate by the current position.
self.worldSceneTranslateNode = TranslateNode()
self.worldScene = WorldScene(dim, textureAtlas, bounds=pendingImport.selection)
self.worldScene.depthOffsetNode.depthOffset = DepthOffset.PreviewRenderer
# transformedWorldTranslateNode contains the transformed preview of the imported
# object, including a world scene that displays the object wrapped by a
# DimensionTransform.
self.transformedWorldTranslateNode = TranslateNode()
self.transformedWorldScene = None
self.addChild(self.transformedWorldTranslateNode)
self.worldSceneTranslateNode.translateOffset = -self.pendingImport.selection.origin
self.worldSceneTranslateNode.addChild(self.worldScene)
self.rotateNode.addChild(self.worldSceneTranslateNode)
# handleNode displays a bounding box that can be moved around, and responds
# to mouse events.
box = BoundingBox(pendingImport.importPos, pendingImport.importBounds.size)
self.handleNode = BoxHandle()
self.handleNode.bounds = box
self.handleNode.resizable = False
self.updateTransformedScene()
self.basePosition = pendingImport.basePosition
self.handleNode.boundsChanged.connect(self.handleBoundsChanged)
self.handleNode.boundsChangedDone.connect(self.handleBoundsChangedDone)
self.addChild(self.handleNode)
# loads the non-transformed world scene asynchronously.
self.loader = WorldLoader(self.worldScene,
list(pendingImport.selection.chunkPositions()))
self.loader.startLoader()
self.pendingImport.positionChanged.connect(self.setPosition)
self.pendingImport.rotationChanged.connect(self.setRotation)
# Emitted when the user finishes dragging the box handle and releases the mouse
# button. Arguments are (newPosition, oldPosition).
importMoved = QtCore.Signal(object, object)
def handleBoundsChangedDone(self, bounds, oldBounds):
point = self.getBaseFromTransformed(bounds.origin)
oldPoint = self.getBaseFromTransformed(oldBounds.origin)
if point != oldPoint:
self.importMoved.emit(point, oldPoint)
def handleBoundsChanged(self, bounds):
point = self.getBaseFromTransformed(bounds.origin)
if self.basePosition != point:
self.basePosition = point
def getBaseFromTransformed(self, point):
offset = self.pendingImport.basePosition - self.pendingImport.importPos
return point + offset
def setPreviewRotation(self, rots):
self.rotateNode.visible = True
self.worldSceneTranslateNode.visible = True
self.transformedWorldTranslateNode.visible = False
self.rotateNode.setRotation(rots)
def setRotation(self, rots):
self.updateTransformedScene()
self.updateBoxHandle()
self.rotateNode.setRotation(rots)
def updateTransformedScene(self):
if self.pendingImport.transformedDim is not None:
log.info("Showing transformed scene")
self.rotateNode.visible = False
self.worldSceneTranslateNode.visible = False
self.transformedWorldTranslateNode.visible = True
if self.transformedWorldScene:
self.transformedWorldTranslateNode.removeChild(self.transformedWorldScene)
self.transformedWorldScene = WorldScene(self.pendingImport.transformedDim,
self.textureAtlas)
self.transformedWorldScene.depthOffsetNode.depthOffset = DepthOffset.PreviewRenderer
self.transformedWorldTranslateNode.addChild(self.transformedWorldScene)
self.updateTransformedSceneOffset()
cPos = list(self.pendingImport.transformedDim.chunkPositions())
self.loader = WorldLoader(self.transformedWorldScene,
cPos)
self.loader.startLoader()
else:
log.info("Hiding transformed scene")
self.rotateNode.visible = True
self.worldSceneTranslateNode.visible = True
self.transformedWorldTranslateNode.visible = False
if self.transformedWorldScene:
self.transformedWorldTranslateNode.removeChild(self.transformedWorldScene)
self.transformedWorldScene = None
def updateTransformedSceneOffset(self):
self.transformedWorldTranslateNode.translateOffset = self.transformedPosition - self.pendingImport.importDim.bounds.origin
@property
def transformedPosition(self):
return self.basePosition + self.pendingImport.importPos - self.pendingImport.basePosition
@property
def basePosition(self):
return self.positionTranslateNode.translateOffset
@basePosition.setter
def basePosition(self, value):
if value == self.positionTranslateNode.translateOffset:
return
self.positionTranslateNode.translateOffset = Vector(*value)
self.updateTransformedSceneOffset()
self.updateBoxHandle()
def setPosition(self, pos):
self.basePosition = pos
def updateBoxHandle(self):
if self.transformedWorldScene is None:
bounds = BoundingBox(self.basePosition, self.pendingImport.bounds.size)
else:
origin = self.transformedPosition
bounds = BoundingBox(origin, self.pendingImport.importBounds.size)
#if self.handleNode.bounds.size != bounds.size:
self.handleNode.bounds = bounds
# --- Mouse events ---
# inherit from BoxHandle?
def mouseMove(self, event):
self.handleNode.mouseMove(event)
def mousePress(self, event):
self.handleNode.mousePress(event)
def mouseRelease(self, event):
self.handleNode.mouseRelease(event)
class PendingImportNode(Node, QtCore.QObject):
__node_id_counter = 0
def __init__(self, pendingImport, textureAtlas):
"""
A scenegraph node displaying an object that will be imported later, including
live and deferred views of the object with transformed items, and a BoxHandle
for moving the item.
Parameters
----------
pendingImport: PendingImport
The object to be imported. The PendingImportNode responds to changes in this
object's position, rotation, and scale.
textureAtlas: TextureAtlas
The textures and block models used to render the preview of the object.
Attributes
----------
basePosition: Vector
The pre-transform position of the pending import. This is equal to
`self.pendingImport.basePosition` except when the node is currently being
dragged.
transformedPosition: Vector
The post-transform position of the pending import. This is equal to
`self.pendingImport.importPos` except when the node is currently being
dragged, scaled, or rotated.
"""
super(PendingImportNode, self).__init__()
self.textureAtlas = textureAtlas
self.pendingImport = pendingImport
dim = pendingImport.sourceDim
# positionTranslateNode contains the non-transformed preview of the imported
# object, including its world scene. This preview will be rotated model-wise
# while the user is dragging the rotate controls.
self.positionTranslateNode = TranslateNode()
self.rotateNode = Rotate3DNode()
self.addChild(self.positionTranslateNode)
self.positionTranslateNode.addChild(self.rotateNode)
self.rotateNode.setAnchor(self.pendingImport.selection.size * 0.5)
# worldSceneTranslateNode is contained by positionTranslateNode, and
# serves to translate the world scene back to 0, 0, 0 so the positionTranslateNode
# can translate by the current position.
self.worldSceneTranslateNode = TranslateNode()
self.worldScene = WorldScene(dim,
textureAtlas,
bounds=pendingImport.selection)
self.worldScene.depthOffsetNode.depthOffset = DepthOffset.PreviewRenderer
# transformedWorldTranslateNode contains the transformed preview of the imported
# object, including a world scene that displays the object wrapped by a
# DimensionTransform.
self.transformedWorldTranslateNode = TranslateNode()
self.transformedWorldScene = None
self.addChild(self.transformedWorldTranslateNode)
self.worldSceneTranslateNode.translateOffset = -self.pendingImport.selection.origin
self.worldSceneTranslateNode.addChild(self.worldScene)
self.rotateNode.addChild(self.worldSceneTranslateNode)
# handleNode displays a bounding box that can be moved around, and responds
# to mouse events.
box = BoundingBox(pendingImport.importPos,
pendingImport.importBounds.size)
self.handleNode = BoxHandle()
self.handleNode.bounds = box
self.handleNode.resizable = False
self.updateTransformedScene()
self.basePosition = pendingImport.basePosition
self.handleNode.boundsChanged.connect(self.handleBoundsChanged)
self.handleNode.boundsChangedDone.connect(self.handleBoundsChangedDone)
self.addChild(self.handleNode)
# loads the non-transformed world scene asynchronously.
self.loader = WorldLoader(
self.worldScene, list(pendingImport.selection.chunkPositions()))
self.loader.startLoader()
self.pendingImport.positionChanged.connect(self.setPosition)
self.pendingImport.rotationChanged.connect(self.setRotation)
# Emitted when the user finishes dragging the box handle and releases the mouse
# button. Arguments are (newPosition, oldPosition).
importMoved = QtCore.Signal(object, object)
def handleBoundsChangedDone(self, bounds, oldBounds):
point = self.getBaseFromTransformed(bounds.origin)
oldPoint = self.getBaseFromTransformed(oldBounds.origin)
if point != oldPoint:
self.importMoved.emit(point, oldPoint)
def handleBoundsChanged(self, bounds):
point = self.getBaseFromTransformed(bounds.origin)
if self.basePosition != point:
self.basePosition = point
def getBaseFromTransformed(self, point):
offset = self.pendingImport.basePosition - self.pendingImport.importPos
return point + offset
def setPreviewRotation(self, rots):
self.rotateNode.visible = True
self.worldSceneTranslateNode.visible = True
self.transformedWorldTranslateNode.visible = False
self.rotateNode.setRotation(rots)
def setRotation(self, rots):
self.updateTransformedScene()
self.updateBoxHandle()
self.rotateNode.setRotation(rots)
def updateTransformedScene(self):
if self.pendingImport.transformedDim is not None:
log.info("Showing transformed scene")
self.rotateNode.visible = False
self.worldSceneTranslateNode.visible = False
self.transformedWorldTranslateNode.visible = True
if self.transformedWorldScene:
self.transformedWorldTranslateNode.removeChild(
self.transformedWorldScene)
self.transformedWorldScene = WorldScene(
self.pendingImport.transformedDim, self.textureAtlas)
self.transformedWorldScene.depthOffsetNode.depthOffset = DepthOffset.PreviewRenderer
self.transformedWorldTranslateNode.addChild(
self.transformedWorldScene)
self.updateTransformedSceneOffset()
cPos = list(self.pendingImport.transformedDim.chunkPositions())
self.loader = WorldLoader(self.transformedWorldScene, cPos)
self.loader.startLoader()
else:
log.info("Hiding transformed scene")
self.rotateNode.visible = True
self.worldSceneTranslateNode.visible = True
self.transformedWorldTranslateNode.visible = False
if self.transformedWorldScene:
self.transformedWorldTranslateNode.removeChild(
self.transformedWorldScene)
self.transformedWorldScene = None
def updateTransformedSceneOffset(self):
self.transformedWorldTranslateNode.translateOffset = self.transformedPosition - self.pendingImport.importDim.bounds.origin
@property
def transformedPosition(self):
return self.basePosition + self.pendingImport.importPos - self.pendingImport.basePosition
@property
def basePosition(self):
return self.positionTranslateNode.translateOffset
@basePosition.setter
def basePosition(self, value):
if value == self.positionTranslateNode.translateOffset:
return
self.positionTranslateNode.translateOffset = Vector(*value)
self.updateTransformedSceneOffset()
self.updateBoxHandle()
def setPosition(self, pos):
self.basePosition = pos
def updateBoxHandle(self):
if self.transformedWorldScene is None:
bounds = BoundingBox(self.basePosition,
self.pendingImport.bounds.size)
else:
origin = self.transformedPosition
bounds = BoundingBox(origin, self.pendingImport.importBounds.size)
#if self.handleNode.bounds.size != bounds.size:
self.handleNode.bounds = bounds
# --- Mouse events ---
# inherit from BoxHandle?
def mouseMove(self, event):
self.handleNode.mouseMove(event)
def mousePress(self, event):
self.handleNode.mousePress(event)
def mouseRelease(self, event):
self.handleNode.mouseRelease(event)
class BrushTool(EditorTool):
name = "Brush"
iconName = "brush"
maxBrushSize = 512
def __init__(self, editorSession, *args, **kwargs):
super(BrushTool, self).__init__(editorSession, *args, **kwargs)
self.toolWidget = BrushToolWidget()
self.brushMode = None
self.brushLoader = None
self.brushModesByName = {
cls.name: cls(self)
for cls in BrushModeClasses
}
brushModes = self.brushModesByName.values()
self.toolWidget.brushModeInput.setModes(brushModes)
BrushModeSetting.connectAndCall(self.modeSettingChanged)
self.cursorWorldScene = None
self.cursorNode = Node("brushCursor")
self.cursorTranslate = Translate()
self.cursorNode.addState(self.cursorTranslate)
self.toolWidget.xSpinSlider.setMinimum(1)
self.toolWidget.ySpinSlider.setMinimum(1)
self.toolWidget.zSpinSlider.setMinimum(1)
self.toolWidget.xSpinSlider.valueChanged.connect(self.setX)
self.toolWidget.ySpinSlider.valueChanged.connect(self.setY)
self.toolWidget.zSpinSlider.valueChanged.connect(self.setZ)
self.toolWidget.brushShapeInput.shapeChanged.connect(self.updateCursor)
self.toolWidget.brushShapeInput.shapeOptionsChanged.connect(
self.updateCursor)
self.fillBlock = editorSession.worldEditor.blocktypes["stone"]
self.brushSize = BrushSizeSetting.value(QtGui.QVector3D(
5, 5, 5)).toTuple() # calls updateCursor
self.toolWidget.xSpinSlider.setValue(self.brushSize[0])
self.toolWidget.ySpinSlider.setValue(self.brushSize[1])
self.toolWidget.zSpinSlider.setValue(self.brushSize[2])
self.toolWidget.hoverSpinSlider.setValue(1)
self.dragPoints = []
@property
def hoverDistance(self):
return self.toolWidget.hoverSpinSlider.value()
_brushSize = (0, 0, 0)
@property
def brushSize(self):
return self._brushSize
@brushSize.setter
def brushSize(self, value):
self._brushSize = value
BrushSizeSetting.setValue(QtGui.QVector3D(*self.brushSize))
self.updateCursor()
def setX(self, val):
x, y, z = self.brushSize
x = float(val)
self.brushSize = x, y, z
def setY(self, val):
x, y, z = self.brushSize
y = float(val)
self.brushSize = x, y, z
def setZ(self, val):
x, y, z = self.brushSize
z = float(val)
self.brushSize = x, y, z
def setBlocktypes(self, types):
if len(types) == 0:
return
self.fillBlock = types[0]
self.updateCursor()
def hoverPosition(self, event):
if event.blockPosition:
vector = (event.blockFace.vector * self.hoverDistance)
pos = event.blockPosition + vector
return pos
def mousePress(self, event):
self.dragPoints[:] = []
pos = self.hoverPosition(event)
if pos:
self.dragPoints.append(pos)
def mouseMove(self, event):
pos = self.hoverPosition(event)
if pos:
self.cursorTranslate.translateOffset = pos
def mouseDrag(self, event):
p2 = self.hoverPosition(event)
if p2:
if len(self.dragPoints):
p1 = self.dragPoints.pop(-1)
points = list(bresenham.bresenham(p1, p2))
self.dragPoints.extend(points)
else:
self.dragPoints.append(p2)
def mouseRelease(self, event):
if not len(self.dragPoints):
pos = self.hoverPosition(event)
if pos:
self.dragPoints.append(pos)
if len(self.dragPoints):
dragPoints = sorted(set(self.dragPoints))
self.dragPoints[:] = []
command = BrushCommand(self.editorSession, dragPoints,
self.options)
self.editorSession.pushCommand(command)
@property
def options(self):
options = {
'brushSize': self.brushSize,
'brushShape': self.brushShape,
'brushMode': self.brushMode
}
options.update(self.brushMode.getOptions())
return options
def modeSettingChanged(self, value):
self.brushMode = self.brushModesByName[value]
stack = self.toolWidget.modeOptionsStack
while stack.count():
stack.removeWidget(stack.widget(0))
if self.brushMode.optionsWidget:
stack.addWidget(self.brushMode.optionsWidget)
@property
def brushShape(self):
return self.toolWidget.brushShapeInput.currentShape
def updateCursor(self):
log.info("Updating brush cursor")
if self.cursorWorldScene:
self.brushLoader.timer.stop()
self.cursorNode.removeChild(self.cursorWorldScene)
self.cursorNode.removeChild(self.cursorBoxNode)
cursorLevel = self.brushMode.createCursorLevel(self)
if cursorLevel is not None:
self.cursorWorldScene = worldscene.WorldScene(
cursorLevel, self.editorSession.textureAtlas)
self.cursorWorldScene.depthOffset.depthOffset = DepthOffsets.PreviewRenderer
self.cursorNode.addChild(self.cursorWorldScene)
self.brushLoader = WorldLoader(self.cursorWorldScene)
self.brushLoader.startLoader()
cursorBox = self.brushMode.brushBoxForPoint((0, 0, 0), self.options)
if cursorBox is not None:
self.cursorBoxNode = SelectionBoxNode()
self.cursorBoxNode.selectionBox = cursorBox
self.cursorBoxNode.filled = False
self.cursorNode.addChild(self.cursorBoxNode)
class BrushTool(EditorTool):
name = "Brush"
iconName = "brush"
maxBrushSize = 512
def __init__(self, editorSession, *args, **kwargs):
super(BrushTool, self).__init__(editorSession, *args, **kwargs)
self.toolWidget = load_ui("editortools/brush.ui")
self.brushMode = None
self.brushLoader = None
self.brushModesByName = {cls.name:cls() for cls in BrushModeClasses}
modes = self.brushModesByName.values()
modes.sort(key=lambda m: m.name)
self.toolWidget.brushModeInput.setModes(modes)
BrushModeSetting.connectAndCall(self.modeSettingChanged)
self.cursorWorldScene = None
self.cursorNode = TranslateNode()
self.toolWidget.xSpinSlider.setMinimum(1)
self.toolWidget.ySpinSlider.setMinimum(1)
self.toolWidget.zSpinSlider.setMinimum(1)
self.toolWidget.xSpinSlider.valueChanged.connect(self.setX)
self.toolWidget.ySpinSlider.valueChanged.connect(self.setY)
self.toolWidget.zSpinSlider.valueChanged.connect(self.setZ)
self.toolWidget.brushShapeInput.shapeChanged.connect(self.updateCursor)
self.toolWidget.brushShapeInput.shapeOptionsChanged.connect(self.updateCursor)
self.fillBlock = editorSession.worldEditor.blocktypes["stone"]
self.brushSize = BrushSizeSetting.value(QtGui.QVector3D(5, 5, 5)).toTuple() # calls updateCursor
self.toolWidget.xSpinSlider.setValue(self.brushSize[0])
self.toolWidget.ySpinSlider.setValue(self.brushSize[1])
self.toolWidget.zSpinSlider.setValue(self.brushSize[2])
@property
def hoverDistance(self):
return self.toolWidget.hoverSpinSlider.value()
_brushSize = (0, 0, 0)
@property
def brushSize(self):
return self._brushSize
@brushSize.setter
def brushSize(self, value):
self._brushSize = value
BrushSizeSetting.setValue(QtGui.QVector3D(*self.brushSize))
self.updateCursor()
def setX(self, val):
x, y, z = self.brushSize
x = float(val)
self.brushSize = x, y, z
def setY(self, val):
x, y, z = self.brushSize
y = float(val)
self.brushSize = x, y, z
def setZ(self, val):
x, y, z = self.brushSize
z = float(val)
self.brushSize = x, y, z
def setBlocktypes(self, types):
if len(types) == 0:
return
self.fillBlock = types[0]
self.updateCursor()
def mousePress(self, event):
pos = event.blockPosition
vector = (event.blockFace.vector * self.hoverDistance)
command = BrushCommand(self.editorSession, [pos + vector], self.options)
self.editorSession.pushCommand(command)
def mouseMove(self, event):
if event.blockPosition:
vector = (event.blockFace.vector * self.hoverDistance)
assert isinstance(vector, Vector), "vector isa %s" % type(vector)
self.cursorNode.translateOffset = event.blockPosition + vector
@property
def options(self):
options = {'brushSize': self.brushSize,
'brushShape': self.brushShape,
'brushMode': self.brushMode}
options.update(self.brushMode.getOptions())
return options
def modeSettingChanged(self, value):
self.brushMode = self.brushModesByName[value]
stack = self.toolWidget.modeOptionsStack
while stack.count():
stack.removeWidget(stack.widget(0))
widget = self.brushMode.createOptionsWidget(self)
if widget:
stack.addWidget(widget)
@property
def brushShape(self):
return self.toolWidget.brushShapeInput.currentShape
def updateCursor(self):
log.info("Updating brush cursor")
if self.cursorWorldScene:
self.brushLoader.timer.stop()
self.cursorNode.removeChild(self.cursorWorldScene)
self.cursorNode.removeChild(self.cursorBoxNode)
cursorLevel = self.brushMode.createCursorLevel(self)
cursorBox = self.brushMode.brushBoxForPoint((0, 0, 0), self.options)
self.cursorBoxNode = SelectionBoxNode()
self.cursorBoxNode.selectionBox = cursorBox
self.cursorBoxNode.filled = False
self.cursorWorldScene = worldscene.WorldScene(cursorLevel, self.editorSession.textureAtlas)
self.cursorWorldScene.depthOffsetNode.depthOffset = DepthOffset.PreviewRenderer
self.cursorNode.addChild(self.cursorWorldScene)
self.cursorNode.addChild(self.cursorBoxNode)
self.brushLoader = WorldLoader(self.cursorWorldScene)
self.brushLoader.startLoader()
class PendingImportNode(Node, QtCore.QObject):
__node_id_counter = 0
def __init__(self, pendingImport, textureAtlas, hasHandle=True):
"""
A scenegraph node displaying an object that will be imported later, including
live and deferred views of the object with transformed items, and a BoxHandle
for moving the item.
Parameters
----------
pendingImport: PendingImport
The object to be imported. The PendingImportNode responds to changes in this
object's position, rotation, and scale.
textureAtlas: TextureAtlas
The textures and block models used to render the preview of the object.
hasHandle: bool
True if this import node should have a user-interactive BoxHandle associated
with it. This is False for the extra copies displayed by a repeated clone.
Attributes
----------
basePosition: Vector
The pre-transform position of the pending import. This is equal to
`self.pendingImport.basePosition` except when the node is currently being
dragged.
transformedPosition: Vector
The post-transform position of the pending import. This is equal to
`self.pendingImport.importPos` except when the node is currently being
dragged, scaled, or rotated.
"""
super(PendingImportNode, self).__init__()
self.textureAtlas = textureAtlas
self.pendingImport = pendingImport
self.hasHandle = hasHandle
dim = pendingImport.sourceDim
self.transformedPosition = Vector(0, 0, 0)
# worldScene is contained by rotateNode, and
# translates the world scene back to 0, 0, 0 so the rotateNode can
# rotate it around the anchor, and the plainSceneNode can translate
# it to the current position.
self.worldScene = WorldScene(dim, textureAtlas, bounds=pendingImport.selection)
self.worldScene.depthOffset.depthOffset = DepthOffsets.PreviewRenderer
self.worldSceneTranslate = Translate(-self.pendingImport.selection.origin)
self.worldScene.addState(self.worldSceneTranslate)
# rotateNode is used to rotate the non-transformed preview during live rotation
self.rotateNode = Rotate3DNode()
self.rotateNode.setAnchor(self.pendingImport.selection.size * 0.5)
self.rotateNode.addChild(self.worldScene)
self.scaleNode = Scale3DNode()
self.scaleNode.setAnchor(self.pendingImport.selection.size * 0.5)
self.scaleNode.addChild(self.rotateNode)
# plainSceneNode contains the non-transformed preview of the imported
# object, including its world scene. This preview will be rotated model-wise
# while the user is dragging the rotate controls.
self.plainSceneNode = Node("plainScene")
self.positionTranslate = Translate()
self.plainSceneNode.addState(self.positionTranslate)
self.plainSceneNode.addChild(self.scaleNode)
self.addChild(self.plainSceneNode)
# transformedSceneNode contains the transformed preview of the imported
# object, including a world scene that displays the object wrapped by a
# DimensionTransform.
self.transformedSceneNode = Node("transformedScene")
self.transformedSceneTranslate = Translate()
self.transformedSceneNode.addState(self.transformedSceneTranslate)
self.transformedWorldScene = None
self.addChild(self.transformedSceneNode)
box = BoundingBox(pendingImport.importPos, pendingImport.importBounds.size)
if hasHandle:
# handleNode displays a bounding box that can be moved around, and responds
# to mouse events.
self.handleNode = BoxHandle()
self.handleNode.bounds = box
self.handleNode.resizable = False
self.boxNode = None
else:
# boxNode displays a plain, non-movable bounding box
self.boxNode = SelectionBoxNode()
self.boxNode.wireColor = (1, 1, 1, .2)
self.boxNode.filled = False
self.handleNode = None
self.addChild(self.boxNode)
self.updateTransformedScene()
self.basePosition = pendingImport.basePosition
if hasHandle:
self.handleNode.boundsChanged.connect(self.handleBoundsChanged)
self.handleNode.boundsChangedDone.connect(self.handleBoundsChangedDone)
self.addChild(self.handleNode)
# loads the non-transformed world scene asynchronously.
self.loader = WorldLoader(self.worldScene,
list(pendingImport.selection.chunkPositions()))
self.loader.startLoader(0.1 if self.hasHandle else 0.0)
self.pendingImport.positionChanged.connect(self.setPosition)
self.pendingImport.rotationChanged.connect(self.setRotation)
self.pendingImport.scaleChanged.connect(self.setScale)
# Emitted when the user finishes dragging the box handle and releases the mouse
# button. Arguments are (newPosition, oldPosition).
importMoved = QtCore.Signal(object, object)
# Emitted while the user is dragging the box handle. Argument is the box origin.
importIsMoving = QtCore.Signal(object)
def handleBoundsChangedDone(self, bounds, oldBounds):
point = self.getBaseFromTransformed(bounds.origin)
oldPoint = self.getBaseFromTransformed(oldBounds.origin)
if point != oldPoint:
self.importMoved.emit(point, oldPoint)
def handleBoundsChanged(self, bounds):
log.info("handleBoundsChanged: %s", bounds)
self.setPreviewBasePosition(bounds.origin)
def setPreviewBasePosition(self, origin):
point = self.getBaseFromTransformed(origin)
if self.basePosition != point:
self.basePosition = point
self.importIsMoving.emit(point)
def getBaseFromTransformed(self, point):
return point - self.pendingImport.transformOffset
def setPreviewRotation(self, rots):
self.plainSceneNode.visible = True
self.transformedSceneNode.visible = False
self.rotateNode.setRotation(rots)
def setRotation(self, rots):
self.updateTransformedScene()
self.updateBoxHandle()
self.rotateNode.setRotation(rots)
def setPreviewScale(self, scale):
self.plainSceneNode.visible = True
self.transformedSceneNode.visible = False
self.scaleNode.setScale(scale)
def setScale(self, scale):
self.updateTransformedScene()
self.updateBoxHandle()
self.scaleNode.setScale(scale)
def updateTransformedScene(self):
if self.pendingImport.transformedDim is not None:
log.info("Showing transformed scene")
self.plainSceneNode.visible = False
self.transformedSceneNode.visible = True
if self.transformedWorldScene:
self.transformedSceneNode.removeChild(self.transformedWorldScene)
self.transformedWorldScene = WorldScene(self.pendingImport.transformedDim,
self.textureAtlas)
self.transformedWorldScene.depthOffset.depthOffset = DepthOffsets.PreviewRenderer
self.transformedSceneNode.addChild(self.transformedWorldScene)
self.updateTransformedPosition()
cPos = list(self.pendingImport.transformedDim.chunkPositions())
self.loader = WorldLoader(self.transformedWorldScene,
cPos)
# ALERT!: self.hasHandle is overloaded with the meaning:
# "not the first clone in a repeated clone"
self.loader.startLoader(0.1 if self.hasHandle else 0.0)
else:
log.info("Hiding transformed scene")
self.plainSceneNode.visible = True
self.transformedSceneNode.visible = False
if self.transformedWorldScene:
self.transformedSceneNode.removeChild(self.transformedWorldScene)
self.transformedWorldScene = None
def updateTransformedPosition(self):
self.transformedPosition = self.basePosition + self.pendingImport.transformOffset
self.transformedSceneTranslate.translateOffset = self.transformedPosition - self.pendingImport.importDim.bounds.origin
def updateBoxHandle(self):
if self.transformedWorldScene is None:
bounds = BoundingBox(self.basePosition, self.pendingImport.bounds.size)
else:
origin = self.transformedPosition
bounds = BoundingBox(origin, self.pendingImport.importBounds.size)
#if self.handleNode.bounds.size != bounds.size:
if self.hasHandle:
self.handleNode.bounds = bounds
else:
self.boxNode.selectionBox = bounds
@property
def basePosition(self):
return self.positionTranslate.translateOffset
@basePosition.setter
def basePosition(self, value):
value = Vector(*value)
if value == self.positionTranslate.translateOffset:
return
self.positionTranslate.translateOffset = value
self.updateTransformedPosition()
self.updateBoxHandle()
def setPosition(self, pos):
self.basePosition = pos
# --- Mouse events ---
# inherit from BoxHandle?
def mouseMove(self, event):
if not self.hasHandle:
return
self.handleNode.mouseMove(event)
def mousePress(self, event):
if not self.hasHandle:
return
self.handleNode.mousePress(event)
def mouseRelease(self, event):
if not self.hasHandle:
return
self.handleNode.mouseRelease(event)
class BrushTool(EditorTool):
name = "Brush"
iconName = "brush"
maxBrushSize = 512
modifiesWorld = True
def __init__(self, editorSession, *args, **kwargs):
super(BrushTool, self).__init__(editorSession, *args, **kwargs)
self.toolWidget = BrushToolWidget()
self.brushMode = None
self.brushLoader = None
self.brushModesByName = {cls.name:cls(self) for cls in BrushModeClasses}
brushModes = self.brushModesByName.values()
self.toolWidget.brushModeInput.setModes(brushModes)
BrushModeSetting.connectAndCall(self.modeSettingChanged)
self.cursorWorldScene = None
self.cursorBoxNode = None
self.cursorNode = Node("brushCursor")
self.cursorTranslate = Translate()
self.cursorNode.addState(self.cursorTranslate)
self.toolWidget.xSpinSlider.setMinimum(1)
self.toolWidget.ySpinSlider.setMinimum(1)
self.toolWidget.zSpinSlider.setMinimum(1)
self.toolWidget.xSpinSlider.valueChanged.connect(self.setX)
self.toolWidget.ySpinSlider.valueChanged.connect(self.setY)
self.toolWidget.zSpinSlider.valueChanged.connect(self.setZ)
self.toolWidget.brushShapeInput.shapeChanged.connect(self.updateCursor)
self.toolWidget.brushShapeInput.shapeOptionsChanged.connect(self.updateCursor)
self.brushSize = BrushSizeSetting.value(QtGui.QVector3D(5, 5, 5)).toTuple() # calls updateCursor
self.toolWidget.xSpinSlider.setValue(self.brushSize[0])
self.toolWidget.ySpinSlider.setValue(self.brushSize[1])
self.toolWidget.zSpinSlider.setValue(self.brushSize[2])
self.toolWidget.hoverSpinSlider.setValue(1)
self.dragPoints = []
@property
def hoverDistance(self):
return self.toolWidget.hoverSpinSlider.value()
_brushSize = (0, 0, 0)
@property
def brushSize(self):
return self._brushSize
@brushSize.setter
def brushSize(self, value):
self._brushSize = value
BrushSizeSetting.setValue(QtGui.QVector3D(*self.brushSize))
self.updateCursor()
def setX(self, val):
x, y, z = self.brushSize
x = float(val)
self.brushSize = x, y, z
def setY(self, val):
x, y, z = self.brushSize
y = float(val)
self.brushSize = x, y, z
def setZ(self, val):
x, y, z = self.brushSize
z = float(val)
self.brushSize = x, y, z
def hoverPosition(self, event):
if event.blockPosition:
vector = (event.blockFace.vector * self.hoverDistance)
pos = event.blockPosition + vector
return pos
def mousePress(self, event):
self.dragPoints[:] = []
pos = self.hoverPosition(event)
if pos:
self.dragPoints.append(pos)
def mouseMove(self, event):
pos = self.hoverPosition(event)
if pos:
self.cursorTranslate.translateOffset = pos
def mouseDrag(self, event):
p2 = self.hoverPosition(event)
if p2:
if len(self.dragPoints):
p1 = self.dragPoints.pop(-1)
points = list(bresenham.bresenham(p1, p2))
self.dragPoints.extend(points)
else:
self.dragPoints.append(p2)
def mouseRelease(self, event):
if not len(self.dragPoints):
pos = self.hoverPosition(event)
if pos:
self.dragPoints.append(pos)
if len(self.dragPoints):
dragPoints = sorted(set(self.dragPoints))
self.dragPoints[:] = []
command = BrushCommand(self.editorSession, dragPoints, self.options)
self.editorSession.pushCommand(command)
@property
def options(self):
options = {'brushSize': self.brushSize,
'brushShape': self.brushShape,
'brushMode': self.brushMode,
'brushHollow': self.brushHollow}
options.update(self.brushMode.getOptions())
return options
def modeSettingChanged(self, value):
self.brushMode = self.brushModesByName[value]
stack = self.toolWidget.modeOptionsStack
while stack.count():
stack.removeWidget(stack.widget(0))
if self.brushMode.optionsWidget:
stack.addWidget(self.brushMode.optionsWidget)
@property
def brushShape(self):
return self.toolWidget.brushShapeInput.currentShape
@property
def brushHollow(self):
return self.toolWidget.hollowCheckBox.isChecked()
def updateCursor(self):
log.info("Updating brush cursor")
if self.cursorWorldScene:
self.brushLoader.timer.stop()
self.cursorNode.removeChild(self.cursorWorldScene)
self.cursorWorldScene = None
if self.cursorBoxNode:
self.cursorNode.removeChild(self.cursorBoxNode)
self.cursorBoxNode = None
cursorLevel = self.brushMode.createCursorLevel(self)
if cursorLevel is not None:
self.cursorWorldScene = worldscene.WorldScene(cursorLevel, self.editorSession.textureAtlas)
self.cursorWorldScene.depthOffset.depthOffset = DepthOffsets.PreviewRenderer
self.cursorNode.addChild(self.cursorWorldScene)
self.brushLoader = WorldLoader(self.cursorWorldScene)
self.brushLoader.startLoader()
cursorBox = self.brushMode.brushBoxForPoint((0, 0, 0), self.options)
if cursorBox is not None:
self.cursorBoxNode = SelectionBoxNode()
self.cursorBoxNode.selectionBox = cursorBox
self.cursorBoxNode.filled = False
self.cursorNode.addChild(self.cursorBoxNode)
class GenerateTool(EditorTool):
name = "Generate"
iconName = "generate"
instantDisplayChunks = 32
def __init__(self, *args, **kwargs):
EditorTool.__init__(self, *args, **kwargs)
self.livePreview = False
self.blockPreview = False
self.glPreview = True
toolWidget = QtGui.QWidget()
self.toolWidget = toolWidget
column = []
self.generatorTypes = [pluginClass(self) for pluginClass in _pluginClasses]
self.currentGenerator = None
if len(self.generatorTypes):
self.currentGenerator = self.generatorTypes[0]
self.generatorTypeInput = QtGui.QComboBox()
self.generatorTypesChanged()
self.generatorTypeInput.currentIndexChanged.connect(self.currentTypeChanged)
self.livePreviewCheckbox = QtGui.QCheckBox("Live Preview")
self.livePreviewCheckbox.setChecked(self.livePreview)
self.livePreviewCheckbox.toggled.connect(self.livePreviewToggled)
self.blockPreviewCheckbox = QtGui.QCheckBox("Block Preview")
self.blockPreviewCheckbox.setChecked(self.blockPreview)
self.blockPreviewCheckbox.toggled.connect(self.blockPreviewToggled)
self.glPreviewCheckbox = QtGui.QCheckBox("GL Preview")
self.glPreviewCheckbox.setChecked(self.glPreview)
self.glPreviewCheckbox.toggled.connect(self.glPreviewToggled)
self.optionsHolder = QtGui.QStackedWidget()
self.optionsHolder.setSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Expanding)
self.generateButton = QtGui.QPushButton(self.tr("Generate"))
self.generateButton.clicked.connect(self.generateClicked)
column.append(self.generatorTypeInput)
column.append(self.livePreviewCheckbox)
column.append(self.blockPreviewCheckbox)
column.append(self.glPreviewCheckbox)
column.append(self.optionsHolder)
column.append(self.generateButton)
self.toolWidget.setLayout(Column(*column))
self.overlayNode = scenenode.Node()
self.sceneHolderNode = Node()
self.sceneTranslate = Translate()
self.sceneHolderNode.addState(self.sceneTranslate)
self.overlayNode.addChild(self.sceneHolderNode)
self.previewNode = None
self.boxHandleNode = BoxHandle()
self.boxHandleNode.boundsChanged.connect(self.boundsDidChange)
self.boxHandleNode.boundsChangedDone.connect(self.boundsDidChangeDone)
self.overlayNode.addChild(self.boxHandleNode)
self.worldScene = None
self.loader = None
self.previewBounds = None
self.schematicBounds = None
self.currentSchematic = None
self.currentTypeChanged(0)
# Name of last selected generator plugin is saved after unloading
# so it can be reselected if it is immediately reloaded
self._lastTypeName = None
_GeneratePlugins.instance.pluginAdded.connect(self.addPlugin)
_GeneratePlugins.instance.pluginRemoved.connect(self.removePlugin)
def removePlugin(self, cls):
log.info("Removing plugin %s", cls.__name__)
self.generatorTypes[:] = [gt for gt in self.generatorTypes if not isinstance(gt, cls)]
self.generatorTypesChanged()
if self.currentGenerator not in self.generatorTypes:
lastTypeName = self.currentGenerator.__class__.__name__
self.currentTypeChanged(0) # resets self._lastTypeName
self._lastTypeName = lastTypeName
def addPlugin(self, cls):
log.info("Adding plugin %s", cls.__name__)
self.generatorTypes.append(cls(self))
self.generatorTypesChanged()
if self._lastTypeName is not None:
if cls.__name__ == self._lastTypeName:
self.currentTypeChanged(len(self.generatorTypes)-1)
def generatorTypesChanged(self):
self.generatorTypeInput.clear()
for gt in self.generatorTypes:
if hasattr(gt, 'displayName'):
displayName = gt.displayName
else:
displayName = gt.__class__.__name__
self.generatorTypeInput.addItem(displayName, gt)
def livePreviewToggled(self, value):
self.livePreview = value
def blockPreviewToggled(self, value):
self.blockPreview = value
if value:
if self.currentSchematic:
self.displaySchematic(self.currentSchematic, self.schematicBounds.origin)
else:
self.updateBlockPreview()
else:
self.clearSchematic()
def glPreviewToggled(self, value):
self.glPreview = value
if value:
self.updateNodePreview() # xxx cache previewNode?
else:
self.clearNode()
def currentTypeChanged(self, index):
# user selected generator type after old type was unloaded, so forget the old type
self._lastTypeName = None
self.optionsHolder.removeWidget(self.optionsHolder.widget(0))
if index < len(self.generatorTypes):
self.currentGenerator = self.generatorTypes[index]
self.optionsHolder.addWidget(self.currentGenerator.getOptionsWidget())
self.updatePreview()
else:
self.currentGenerator = None
self.clearSchematic()
self.clearNode()
log.info("Chose generator %s", repr(self.currentGenerator))
def mousePress(self, event):
self.boxHandleNode.mousePress(event)
def mouseMove(self, event):
self.boxHandleNode.mouseMove(event)
def mouseRelease(self, event):
self.boxHandleNode.mouseRelease(event)
def boundsDidChange(self, bounds):
# box still being resized
if not self.currentGenerator:
return
if not self.livePreview:
return
self.previewBounds = bounds
self.currentGenerator.boundsChanged(bounds)
self.updatePreview()
def boundsDidChangeDone(self, bounds, oldBounds):
# box finished resize
if not self.currentGenerator:
return
self.previewBounds = bounds
self.schematicBounds = bounds
self.currentGenerator.boundsChanged(bounds)
self.updatePreview()
def clearNode(self):
if self.previewNode:
self.overlayNode.removeChild(self.previewNode)
self.previewNode = None
def updatePreview(self):
if self.blockPreview:
self.updateBlockPreview()
else:
self.clearSchematic()
if self.glPreview:
self.updateNodePreview()
else:
self.clearNode()
def updateBlockPreview(self):
bounds = self.previewBounds
if bounds is not None and bounds.volume > 0:
self.generateNextSchematic(bounds)
else:
self.clearSchematic()
def updateNodePreview(self):
bounds = self.previewBounds
if self.currentGenerator is None:
return
if bounds is not None and bounds.volume > 0:
try:
node = self.currentGenerator.getPreviewNode(bounds)
except Exception:
log.exception("Error while getting scene nodes from generator:")
else:
if node is not None:
self.clearNode()
if isinstance(node, list):
nodes = node
node = scenenode.Node()
for c in nodes:
node.addChild(c)
self.overlayNode.addChild(node)
self.previewNode = node
def generateNextSchematic(self, bounds):
if bounds is None:
self.clearSchematic()
return
if self.currentGenerator is None:
return
try:
schematic = self.currentGenerator.generate(bounds, self.editorSession.worldEditor.blocktypes)
self.currentSchematic = schematic
self.displaySchematic(schematic, bounds.origin)
except Exception as e:
log.exception("Error while running generator %s: %s", self.currentGenerator, e)
QtGui.QMessageBox.warning(QtGui.qApp.mainWindow, "Error while running generator",
"An error occurred while running the generator: \n %s.\n\n"
"Traceback: %s" % (e, traceback.format_exc()))
self.livePreview = False
def displaySchematic(self, schematic, offset):
if schematic is not None:
dim = schematic.getDimension()
if self.worldScene:
self.sceneHolderNode.removeChild(self.worldScene)
self.loader.timer.stop()
self.loader = None
atlas = self.editorSession.textureAtlas
self.worldScene = WorldScene(dim, atlas)
self.sceneTranslate.translateOffset = offset
self.sceneHolderNode.addChild(self.worldScene)
self.loader = WorldLoader(self.worldScene)
if dim.chunkCount() <= self.instantDisplayChunks:
exhaust(self.loader.work())
else:
self.loader.startLoader()
else:
self.clearSchematic()
def clearSchematic(self):
if self.worldScene:
self.sceneHolderNode.removeChild(self.worldScene)
self.worldScene = None
self.loader.timer.stop()
self.loader = None
def generateClicked(self):
if self.currentGenerator is None:
return
if self.schematicBounds is None:
log.info("schematicBounds is None, not generating")
return
if self.currentSchematic is None:
log.info("Generating new schematic for import")
currentSchematic = self.currentGenerator.generate(self.schematicBounds, self.editorSession.worldEditor.blocktypes)
else:
log.info("Importing previously generated schematic.")
currentSchematic = self.currentSchematic
command = GenerateCommand(self, self.schematicBounds)
try:
with command.begin():
if currentSchematic is not None:
task = self.editorSession.currentDimension.importSchematicIter(currentSchematic, self.schematicBounds.origin)
showProgress(self.tr("Importing generated object..."), task)
else:
task = self.currentGenerator.generateInWorld(self.schematicBounds, self.editorSession.currentDimension)
showProgress(self.tr("Generating object in world..."), task)
except Exception as e:
log.exception("Error while importing or generating in world: %r" % e)
command.undo()
else:
self.editorSession.pushCommand(command)
class PendingImportNode(Node, QtCore.QObject):
__node_id_counter = 0
def __init__(self, pendingImport, textureAtlas, hasHandle=True):
"""
A scenegraph node displaying an object that will be imported later, including
live and deferred views of the object with transformed items, and a BoxHandle
for moving the item.
Parameters
----------
pendingImport: PendingImport
The object to be imported. The PendingImportNode responds to changes in this
object's position, rotation, and scale.
textureAtlas: TextureAtlas
The textures and block models used to render the preview of the object.
hasHandle: bool
True if this import node should have a user-interactive BoxHandle associated
with it. This is False for the extra copies displayed by a repeated clone.
Attributes
----------
basePosition: Vector
The pre-transform position of the pending import. This is equal to
`self.pendingImport.basePosition` except when the node is currently being
dragged.
transformedPosition: Vector
The post-transform position of the pending import. This is equal to
`self.pendingImport.importPos` except when the node is currently being
dragged, scaled, or rotated.
"""
super(PendingImportNode, self).__init__()
self.textureAtlas = textureAtlas
self.pendingImport = pendingImport
self.hasHandle = hasHandle
dim = pendingImport.sourceDim
self.transformedPosition = Vector(0, 0, 0)
# worldScene is contained by rotateNode, and
# translates the world scene back to 0, 0, 0 so the rotateNode can
# rotate it around the anchor, and the plainSceneNode can translate
# it to the current position.
self.worldScene = WorldScene(dim,
textureAtlas,
bounds=pendingImport.selection)
self.worldScene.depthOffset.depthOffset = DepthOffsets.PreviewRenderer
self.worldSceneTranslate = Translate(
-self.pendingImport.selection.origin)
self.worldScene.addState(self.worldSceneTranslate)
# rotateNode is used to rotate the non-transformed preview during live rotation
self.rotateNode = Rotate3DNode()
self.rotateNode.setAnchor(self.pendingImport.selection.size * 0.5)
self.rotateNode.addChild(self.worldScene)
self.scaleNode = Scale3DNode()
self.scaleNode.setAnchor(self.pendingImport.selection.size * 0.5)
self.scaleNode.addChild(self.rotateNode)
# plainSceneNode contains the non-transformed preview of the imported
# object, including its world scene. This preview will be rotated model-wise
# while the user is dragging the rotate controls.
self.plainSceneNode = Node("plainScene")
self.positionTranslate = Translate()
self.plainSceneNode.addState(self.positionTranslate)
self.plainSceneNode.addChild(self.scaleNode)
self.addChild(self.plainSceneNode)
# transformedSceneNode contains the transformed preview of the imported
# object, including a world scene that displays the object wrapped by a
# DimensionTransform.
self.transformedSceneNode = Node("transformedScene")
self.transformedSceneTranslate = Translate()
self.transformedSceneNode.addState(self.transformedSceneTranslate)
self.transformedWorldScene = None
self.addChild(self.transformedSceneNode)
box = BoundingBox(pendingImport.importPos,
pendingImport.importBounds.size)
if hasHandle:
# handleNode displays a bounding box that can be moved around, and responds
# to mouse events.
self.handleNode = BoxHandle()
self.handleNode.bounds = box
self.handleNode.resizable = False
self.boxNode = None
else:
# boxNode displays a plain, non-movable bounding box
self.boxNode = SelectionBoxNode()
self.boxNode.wireColor = (1, 1, 1, .2)
self.boxNode.filled = False
self.handleNode = None
self.addChild(self.boxNode)
self.updateTransformedScene()
self.basePosition = pendingImport.basePosition
if hasHandle:
self.handleNode.boundsChanged.connect(self.handleBoundsChanged)
self.handleNode.boundsChangedDone.connect(
self.handleBoundsChangedDone)
self.addChild(self.handleNode)
# loads the non-transformed world scene asynchronously.
self.loader = WorldLoader(
self.worldScene, list(pendingImport.selection.chunkPositions()))
self.loader.startLoader(0.1 if self.hasHandle else 0.0)
self.pendingImport.positionChanged.connect(self.setPosition)
self.pendingImport.rotationChanged.connect(self.setRotation)
self.pendingImport.scaleChanged.connect(self.setScale)
# Emitted when the user finishes dragging the box handle and releases the mouse
# button. Arguments are (newPosition, oldPosition).
importMoved = QtCore.Signal(object, object)
# Emitted while the user is dragging the box handle. Argument is the box origin.
importIsMoving = QtCore.Signal(object)
def handleBoundsChangedDone(self, bounds, oldBounds):
point = self.getBaseFromTransformed(bounds.origin)
oldPoint = self.getBaseFromTransformed(oldBounds.origin)
if point != oldPoint:
self.importMoved.emit(point, oldPoint)
def handleBoundsChanged(self, bounds):
log.info("handleBoundsChanged: %s", bounds)
self.setPreviewBasePosition(bounds.origin)
def setPreviewBasePosition(self, origin):
point = self.getBaseFromTransformed(origin)
if self.basePosition != point:
self.basePosition = point
self.importIsMoving.emit(point)
def getBaseFromTransformed(self, point):
return point - self.pendingImport.transformOffset
def setPreviewRotation(self, rots):
self.plainSceneNode.visible = True
self.transformedSceneNode.visible = False
self.rotateNode.setRotation(rots)
def setRotation(self, rots):
self.updateTransformedScene()
self.updateBoxHandle()
self.rotateNode.setRotation(rots)
def setPreviewScale(self, scale):
self.plainSceneNode.visible = True
self.transformedSceneNode.visible = False
self.scaleNode.setScale(scale)
def setScale(self, scale):
self.updateTransformedScene()
self.updateBoxHandle()
self.scaleNode.setScale(scale)
def updateTransformedScene(self):
if self.pendingImport.transformedDim is not None:
log.info("Showing transformed scene")
self.plainSceneNode.visible = False
self.transformedSceneNode.visible = True
if self.transformedWorldScene:
self.transformedSceneNode.removeChild(
self.transformedWorldScene)
self.transformedWorldScene = WorldScene(
self.pendingImport.transformedDim, self.textureAtlas)
self.transformedWorldScene.depthOffset.depthOffset = DepthOffsets.PreviewRenderer
self.transformedSceneNode.addChild(self.transformedWorldScene)
self.updateTransformedPosition()
cPos = list(self.pendingImport.transformedDim.chunkPositions())
self.loader = WorldLoader(self.transformedWorldScene, cPos)
# ALERT!: self.hasHandle is overloaded with the meaning:
# "not the first clone in a repeated clone"
self.loader.startLoader(0.1 if self.hasHandle else 0.0)
else:
log.info("Hiding transformed scene")
self.plainSceneNode.visible = True
self.transformedSceneNode.visible = False
if self.transformedWorldScene:
self.transformedSceneNode.removeChild(
self.transformedWorldScene)
self.transformedWorldScene = None
def updateTransformedPosition(self):
self.transformedPosition = self.basePosition + self.pendingImport.transformOffset
self.transformedSceneTranslate.translateOffset = self.transformedPosition - self.pendingImport.importDim.bounds.origin
def updateBoxHandle(self):
if self.transformedWorldScene is None:
bounds = BoundingBox(self.basePosition,
self.pendingImport.bounds.size)
else:
origin = self.transformedPosition
bounds = BoundingBox(origin, self.pendingImport.importBounds.size)
#if self.handleNode.bounds.size != bounds.size:
if self.hasHandle:
self.handleNode.bounds = bounds
else:
self.boxNode.selectionBox = bounds
@property
def basePosition(self):
return self.positionTranslate.translateOffset
@basePosition.setter
def basePosition(self, value):
value = Vector(*value)
if value == self.positionTranslate.translateOffset:
return
self.positionTranslate.translateOffset = value
self.updateTransformedPosition()
self.updateBoxHandle()
def setPosition(self, pos):
self.basePosition = pos
# --- Mouse events ---
# inherit from BoxHandle?
def mouseMove(self, event):
if not self.hasHandle:
return
self.handleNode.mouseMove(event)
def mousePress(self, event):
if not self.hasHandle:
return
self.handleNode.mousePress(event)
def mouseRelease(self, event):
if not self.hasHandle:
return
self.handleNode.mouseRelease(event)
class BrushTool(EditorTool):
name = "Brush"
iconName = "brush"
maxBrushSize = 512
def __init__(self, editorSession, *args, **kwargs):
super(BrushTool, self).__init__(editorSession, *args, **kwargs)
self.toolWidget = load_ui("editortools/brush.ui")
self.brushMode = None
self.brushLoader = None
self.brushModesByName = {cls.name: cls() for cls in BrushModeClasses}
modes = self.brushModesByName.values()
modes.sort(key=lambda m: m.name)
self.toolWidget.brushModeInput.setModes(modes)
BrushModeSetting.connectAndCall(self.modeSettingChanged)
self.cursorWorldScene = None
self.cursorNode = TranslateNode()
self.toolWidget.xSpinSlider.setMinimum(1)
self.toolWidget.ySpinSlider.setMinimum(1)
self.toolWidget.zSpinSlider.setMinimum(1)
self.toolWidget.xSpinSlider.valueChanged.connect(self.setX)
self.toolWidget.ySpinSlider.valueChanged.connect(self.setY)
self.toolWidget.zSpinSlider.valueChanged.connect(self.setZ)
self.toolWidget.brushShapeInput.shapeChanged.connect(self.updateCursor)
self.toolWidget.brushShapeInput.shapeOptionsChanged.connect(
self.updateCursor)
self.fillBlock = editorSession.worldEditor.blocktypes["stone"]
self.brushSize = BrushSizeSetting.value(QtGui.QVector3D(
5, 5, 5)).toTuple() # calls updateCursor
self.toolWidget.xSpinSlider.setValue(self.brushSize[0])
self.toolWidget.ySpinSlider.setValue(self.brushSize[1])
self.toolWidget.zSpinSlider.setValue(self.brushSize[2])
@property
def hoverDistance(self):
return self.toolWidget.hoverSpinSlider.value()
_brushSize = (0, 0, 0)
@property
def brushSize(self):
return self._brushSize
@brushSize.setter
def brushSize(self, value):
self._brushSize = value
BrushSizeSetting.setValue(QtGui.QVector3D(*self.brushSize))
self.updateCursor()
def setX(self, val):
x, y, z = self.brushSize
x = float(val)
self.brushSize = x, y, z
def setY(self, val):
x, y, z = self.brushSize
y = float(val)
self.brushSize = x, y, z
def setZ(self, val):
x, y, z = self.brushSize
z = float(val)
self.brushSize = x, y, z
def setBlocktypes(self, types):
if len(types) == 0:
return
self.fillBlock = types[0]
self.updateCursor()
def mousePress(self, event):
pos = event.blockPosition
vector = (event.blockFace.vector * self.hoverDistance)
command = BrushCommand(self.editorSession, [pos + vector],
self.options)
self.editorSession.pushCommand(command)
def mouseMove(self, event):
if event.blockPosition:
vector = (event.blockFace.vector * self.hoverDistance)
assert isinstance(vector, Vector), "vector isa %s" % type(vector)
self.cursorNode.translateOffset = event.blockPosition + vector
@property
def options(self):
options = {
'brushSize': self.brushSize,
'brushShape': self.brushShape,
'brushMode': self.brushMode
}
options.update(self.brushMode.getOptions())
return options
def modeSettingChanged(self, value):
self.brushMode = self.brushModesByName[value]
stack = self.toolWidget.modeOptionsStack
while stack.count():
stack.removeWidget(stack.widget(0))
widget = self.brushMode.createOptionsWidget(self)
if widget:
stack.addWidget(widget)
@property
def brushShape(self):
return self.toolWidget.brushShapeInput.currentShape
def updateCursor(self):
log.info("Updating brush cursor")
if self.cursorWorldScene:
self.brushLoader.timer.stop()
self.cursorNode.removeChild(self.cursorWorldScene)
self.cursorNode.removeChild(self.cursorBoxNode)
cursorLevel = self.brushMode.createCursorLevel(self)
cursorBox = self.brushMode.brushBoxForPoint((0, 0, 0), self.options)
self.cursorBoxNode = SelectionBoxNode()
self.cursorBoxNode.selectionBox = cursorBox
self.cursorBoxNode.filled = False
self.cursorWorldScene = worldscene.WorldScene(
cursorLevel, self.editorSession.textureAtlas)
self.cursorWorldScene.depthOffsetNode.depthOffset = DepthOffset.PreviewRenderer
self.cursorNode.addChild(self.cursorWorldScene)
self.cursorNode.addChild(self.cursorBoxNode)
self.brushLoader = WorldLoader(self.cursorWorldScene)
self.brushLoader.startLoader()