def _initialize(self) -> None: supports_vao = OpenGLContext.supportsVertexArrayObjects( ) # fill the OpenGLContext.properties Logger.log("d", "Support for Vertex Array Objects: %s", supports_vao) OpenGL() self._gl = OpenGL.getInstance().getBindingsObject() self._default_material = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "default.shader")) #type: ShaderProgram self._render_passes.add( DefaultPass(self._viewport_width, self._viewport_height)) self._render_passes.add( SelectionPass(self._viewport_width, self._viewport_height)) self._render_passes.add( CompositePass(self._viewport_width, self._viewport_height)) buffer = QOpenGLBuffer(QOpenGLBuffer.VertexBuffer) buffer.create() buffer.bind() buffer.allocate(120) data = numpy.array([ -1.0, -1.0, 0.0, 1.0, 1.0, 0.0, -1.0, 1.0, 0.0, -1.0, -1.0, 0.0, 1.0, -1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0 ], dtype=numpy.float32).tostring() buffer.write(0, data, len(data)) buffer.release() self._quad_buffer = buffer self._initialized = True self.initialized.emit()
def _initialize(self): OpenGL.setInstance(QtOpenGL()) self._gl = OpenGL.getInstance().getBindingsObject() self._default_material = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "default.shader")) self._render_passes.add(DefaultPass(self._viewport_width, self._viewport_height)) self._render_passes.add(SelectionPass(self._viewport_width, self._viewport_height)) self._render_passes.add(CompositePass(self._viewport_width, self._viewport_height)) buffer = QOpenGLBuffer(QOpenGLBuffer.VertexBuffer) buffer.create() buffer.bind() buffer.allocate(120) data = numpy.array([ -1.0, -1.0, 0.0, 1.0, 1.0, 0.0, -1.0, 1.0, 0.0, -1.0, -1.0, 0.0, 1.0, -1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0 ], dtype = numpy.float32).tostring() buffer.write(0, data, len(data)) buffer.release() self._quad_buffer = buffer self._initialized = True
def __init__(self, width, height): super().__init__("selection", width, height, -999) self._shader = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "selection.shader")) self._face_shader = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "select_face.shader")) self._tool_handle_shader = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "default.shader")) self._gl = OpenGL.getInstance().getBindingsObject() self._scene = Application.getInstance().getController().getScene() self._renderer = Application.getInstance().getRenderer() self._selection_map = {} self._toolhandle_selection_map = { self._dropAlpha(ToolHandle.DisabledSelectionColor): ToolHandle.NoAxis, self._dropAlpha(ToolHandle.XAxisSelectionColor): ToolHandle.XAxis, self._dropAlpha(ToolHandle.YAxisSelectionColor): ToolHandle.YAxis, self._dropAlpha(ToolHandle.ZAxisSelectionColor): ToolHandle.ZAxis, self._dropAlpha(ToolHandle.AllAxisSelectionColor): ToolHandle.AllAxis, ToolHandle.DisabledSelectionColor: ToolHandle.NoAxis, ToolHandle.XAxisSelectionColor: ToolHandle.XAxis, ToolHandle.YAxisSelectionColor: ToolHandle.YAxis, ToolHandle.ZAxisSelectionColor: ToolHandle.ZAxis, ToolHandle.AllAxisSelectionColor: ToolHandle.AllAxis } self._mode = SelectionPass.SelectionMode.OBJECTS Selection.selectedFaceChanged.connect(self._onSelectedFaceChanged) self._output = None
def __init__(self, width, height): super().__init__("selection", width, height, -999) self._shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "selection.shader")) self._tool_handle_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "default.shader")) self._gl = OpenGL.getInstance().getBindingsObject() self._scene = Application.getInstance().getController().getScene() self._renderer = Application.getInstance().getRenderer() self._selection_map = {} self._toolhandle_selection_map = { self._dropAlpha(ToolHandle.DisabledSelectionColor): ToolHandle.NoAxis, self._dropAlpha(ToolHandle.XAxisSelectionColor): ToolHandle.XAxis, self._dropAlpha(ToolHandle.YAxisSelectionColor): ToolHandle.YAxis, self._dropAlpha(ToolHandle.ZAxisSelectionColor): ToolHandle.ZAxis, self._dropAlpha(ToolHandle.AllAxisSelectionColor): ToolHandle.AllAxis, ToolHandle.DisabledSelectionColor: ToolHandle.NoAxis, ToolHandle.XAxisSelectionColor: ToolHandle.XAxis, ToolHandle.YAxisSelectionColor: ToolHandle.YAxis, ToolHandle.ZAxisSelectionColor: ToolHandle.ZAxis, ToolHandle.AllAxisSelectionColor: ToolHandle.AllAxis } self._output = None
def beginRendering(self): scene = self.getController().getScene() renderer = self.getRenderer() if not self._enabled_shader: self._enabled_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "overhang.shader")) if not self._disabled_shader: self._disabled_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "striped.shader")) self._disabled_shader.setUniformValue("u_diffuseColor1", [0.48, 0.48, 0.48, 1.0]) self._disabled_shader.setUniformValue("u_diffuseColor2", [0.68, 0.68, 0.68, 1.0]) self._disabled_shader.setUniformValue("u_width", 50.0) if Application.getInstance().getGlobalContainerStack(): if Preferences.getInstance().getValue("view/show_overhang"): angle = Application.getInstance().getGlobalContainerStack().getProperty("support_angle", "value") if angle is not None: self._enabled_shader.setUniformValue("u_overhangAngle", math.cos(math.radians(90 - angle))) else: self._enabled_shader.setUniformValue("u_overhangAngle", math.cos(math.radians(0))) #Overhang angle of 0 causes no area at all to be marked as overhang. else: self._enabled_shader.setUniformValue("u_overhangAngle", math.cos(math.radians(0))) for node in DepthFirstIterator(scene.getRoot()): if not node.render(renderer): if node.getMeshData() and node.isVisible(): # TODO: Find a better way to handle this #if node.getBoundingBoxMesh(): # renderer.queueNode(scene.getRoot(), mesh = node.getBoundingBoxMesh(),mode = Renderer.RenderLines) uniforms = {} if self._extruders_model.rowCount() > 0: # Get color to render this mesh in from ExtrudersModel extruder_index = 0 extruder_id = node.callDecoration("getActiveExtruder") if extruder_id: extruder_index = max(0, self._extruders_model.find("id", extruder_id)) extruder_color = self._extruders_model.getItem(extruder_index)["colour"] try: # Colors are passed as rgb hex strings (eg "#ffffff"), and the shader needs # an rgba list of floats (eg [1.0, 1.0, 1.0, 1.0]) uniforms["diffuse_color"] = [ int(extruder_color[1:3], 16) / 255, int(extruder_color[3:5], 16) / 255, int(extruder_color[5:7], 16) / 255, 1.0 ] except ValueError: pass if hasattr(node, "_outside_buildarea"): if node._outside_buildarea: renderer.queueNode(node, shader = self._disabled_shader) else: renderer.queueNode(node, shader = self._enabled_shader, uniforms = uniforms) else: renderer.queueNode(node, material = self._enabled_shader, uniforms = uniforms) if node.callDecoration("isGroup"): renderer.queueNode(scene.getRoot(), mesh = node.getBoundingBoxMesh(), mode = Renderer.RenderLines)
def render(self, renderer): if not self.getMeshData(): return True if not self._shader: self._shader = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "default.shader")) self._grid_shader = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "grid.shader")) renderer.queueNode(self, mode=RenderBatch.RenderMode.Lines) renderer.queueNode(self, mesh=self._grid_mesh, shader=self._grid_shader, backface_cull=True) if self._disallowed_area_mesh: renderer.queueNode(self, mesh=self._disallowed_area_mesh, shader=self._shader, transparent=True, backface_cull=True, sort=-9) if self._error_mesh: renderer.queueNode(self, mesh=self._error_mesh, shader=self._shader, transparent=True, backface_cull=True, sort=-8) return True
def _initialize(self): OpenGL.setInstance(QtOpenGL()) self._gl = OpenGL.getInstance().getBindingsObject() self._default_material = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "default.shader")) self._render_passes.add( DefaultPass(self._viewport_width, self._viewport_height)) self._render_passes.add( SelectionPass(self._viewport_width, self._viewport_height)) self._render_passes.add( CompositePass(self._viewport_width, self._viewport_height)) buffer = QOpenGLBuffer(QOpenGLBuffer.VertexBuffer) buffer.create() buffer.bind() buffer.allocate(120) data = numpy.array([ -1.0, -1.0, 0.0, 1.0, 1.0, 0.0, -1.0, 1.0, 0.0, -1.0, -1.0, 0.0, 1.0, -1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0 ], dtype=numpy.float32).tostring() buffer.write(0, data, len(data)) buffer.release() self._quad_buffer = buffer self._initialized = True self.initialized.emit()
def __init__(self, width, height): super().__init__("composite", width, height, RenderPass.MaximumPriority) self._shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "composite.shader")) self._gl = OpenGL.getInstance().getBindingsObject() self._renderer = Application.getInstance().getRenderer() self._layer_bindings = [ "default", "selection" ]
def __init__(self, width, height): super().__init__("composite", width, height, RenderPass.MaximumPriority) self._shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "composite.shader")) theme = Application.getInstance().getTheme() self._shader.setUniformValue("u_background_color", Color(*theme.getColor("viewport_background").getRgb())) self._shader.setUniformValue("u_outline_color", Color(*theme.getColor("model_selection_outline").getRgb())) self._gl = OpenGL.getInstance().getBindingsObject() self._renderer = Application.getInstance().getRenderer() self._layer_bindings = [ "default", "selection" ]
def render(self): if not self._layer_shader: self._layer_shader = OpenGL.getInstance().createShaderProgram(os.path.join(PluginRegistry.getInstance().getPluginPath("LayerView"), "layers.shader")) # Use extruder 0 if the extruder manager reports extruder index -1 (for single extrusion printers) self._layer_shader.setUniformValue("u_active_extruder", float(max(0, self._extruder_manager.activeExtruderIndex))) if not self._tool_handle_shader: self._tool_handle_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "toolhandle.shader")) self.bind() tool_handle_batch = RenderBatch(self._tool_handle_shader, type = RenderBatch.RenderType.Overlay) for node in DepthFirstIterator(self._scene.getRoot()): if isinstance(node, ToolHandle): tool_handle_batch.addItem(node.getWorldTransformation(), mesh = node.getSolidMesh()) elif isinstance(node, SceneNode) and node.getMeshData() and node.isVisible(): layer_data = node.callDecoration("getLayerData") if not layer_data: continue # Render all layers below a certain number as line mesh instead of vertices. if self._layerview._current_layer_num - self._layerview._solid_layers > -1 and not self._layerview._only_show_top_layers: start = 0 end = 0 element_counts = layer_data.getElementCounts() for layer, counts in element_counts.items(): if layer + self._layerview._solid_layers > self._layerview._current_layer_num: break end += counts # This uses glDrawRangeElements internally to only draw a certain range of lines. batch = RenderBatch(self._layer_shader, type = RenderBatch.RenderType.Solid, mode = RenderBatch.RenderMode.Lines, range = (start, end)) batch.addItem(node.getWorldTransformation(), layer_data) batch.render(self._scene.getActiveCamera()) # Create a new batch that is not range-limited batch = RenderBatch(self._layer_shader, type = RenderBatch.RenderType.Solid) if self._layerview._current_layer_mesh: batch.addItem(node.getWorldTransformation(), self._layerview._current_layer_mesh) if self._layerview._current_layer_jumps: batch.addItem(node.getWorldTransformation(), self._layerview._current_layer_jumps) if len(batch.items) > 0: batch.render(self._scene.getActiveCamera()) # Render toolhandles on top of the layerview if len(tool_handle_batch.items) > 0: tool_handle_batch.render(self._scene.getActiveCamera()) self.release()
def __init__(self, width, height): super().__init__("selection", width, height, -999) self._shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "selection.shader")) self._tool_handle_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "default.shader")) self._gl = OpenGL.getInstance().getBindingsObject() self._scene = Application.getInstance().getController().getScene() self._renderer = Application.getInstance().getRenderer() self._selection_map = {} self._output = None
def beginRendering(self): scene = self.getController().getScene() renderer = self.getRenderer() if not self._enabled_shader: self._enabled_shader = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "overhang.shader")) if not self._disabled_shader: self._disabled_shader = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "overhang.shader")) self._disabled_shader.setUniformValue("u_diffuseColor", [0.68, 0.68, 0.68, 1.0]) self._disabled_shader.setUniformValue("u_overhangAngle", math.cos(math.radians(0))) if Application.getInstance().getMachineManager().getWorkingProfile(): profile = Application.getInstance().getMachineManager( ).getWorkingProfile() if Preferences.getInstance().getValue("view/show_overhang"): angle = profile.getSettingValue("support_angle") if angle != None: self._enabled_shader.setUniformValue( "u_overhangAngle", math.cos(math.radians(90 - angle))) else: self._enabled_shader.setUniformValue( "u_overhangAngle", math.cos(math.radians(0)) ) #Overhang angle of 0 causes no area at all to be marked as overhang. else: self._enabled_shader.setUniformValue("u_overhangAngle", math.cos(math.radians(0))) for node in DepthFirstIterator(scene.getRoot()): if not node.render(renderer): if node.getMeshData() and node.isVisible(): # TODO: Find a better way to handle this #if node.getBoundingBoxMesh(): # renderer.queueNode(scene.getRoot(), mesh = node.getBoundingBoxMesh(),mode = Renderer.RenderLines) if hasattr(node, "_outside_buildarea"): if node._outside_buildarea: renderer.queueNode(node, shader=self._disabled_shader) else: renderer.queueNode(node, shader=self._enabled_shader) else: renderer.queueNode(node, material=self._enabled_shader) if node.callDecoration("isGroup"): renderer.queueNode(scene.getRoot(), mesh=node.getBoundingBoxMesh(), mode=Renderer.RenderLines)
def render(self, renderer): if not self.getMeshData(): return True if not self._shader: self._shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "default.shader")) self._grid_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "grid.shader")) renderer.queueNode(self, mode = RenderBatch.RenderMode.Lines) renderer.queueNode(self, mesh = self._grid_mesh, shader = self._grid_shader, backface_cull = True) if self._disallowed_area_mesh: renderer.queueNode(self, mesh = self._disallowed_area_mesh, shader = self._shader, transparent = True, backface_cull = True, sort = -9) return True
def _updateTexture(self): if not self._global_container_stack or not OpenGL.getInstance(): return self._texture = OpenGL.getInstance().createTexture() container = self._global_container_stack.findContainer( {"platform_texture": "*"}) if container: texture_file = container.getMetaDataEntry("platform_texture") self._texture.load( Resources.getPath(Resources.Images, texture_file)) # Note: if no texture file is specified, a 1 x 1 pixel transparent image is created # by UM.GL.QtTexture to prevent rendering issues if self._shader: self._shader.setTexture(0, self._texture)
def __init__(self, width, height): super().__init__("selection", width, height, -999) self._shader = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "selection.shader")) self._tool_handle_shader = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "default.shader")) self._gl = OpenGL.getInstance().getBindingsObject() self._scene = Application.getInstance().getController().getScene() self._renderer = Application.getInstance().getRenderer() self._selection_map = {} self._output = None
def _updateTexture(self): if not self._machine_instance or not OpenGL.getInstance(): return texture_file = self._machine_instance.getMachineDefinition().getPlatformTexture() if texture_file: self._texture = OpenGL.getInstance().createTexture() self._texture.load(Resources.getPath(Resources.Images, texture_file)) if self._shader: self._shader.setTexture(0, self._texture) else: self._texture = None if self._shader: self._shader.setTexture(0, None)
def _updateTexture(self): if not self._global_container_stack or not OpenGL.getInstance(): return self._texture = OpenGL.getInstance().createTexture() container = self._global_container_stack.findContainer({"platform_texture":"*"}) if container: texture_file = container.getMetaDataEntry("platform_texture") self._texture.load(Resources.getPath(Resources.Images, texture_file)) # Note: if no texture file is specified, a 1 x 1 pixel transparent image is created # by UM.GL.QtTexture to prevent rendering issues if self._shader: self._shader.setTexture(0, self._texture)
def beginRendering(self): # Convenience setup scene = self.getController().getScene() renderer = self.getRenderer() if not self._shader: self._shader = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "color.shader")) self._shader.setUniformValue("u_color", Color(32, 32, 32, 170)) for node in DepthFirstIterator(scene.getRoot()): if not node.render(renderer): # For now we only render nodes that indicate that they need rendering. if node.getMeshData(): renderer.queueNode(scene.getRoot(), mesh=self._getAxisMesh(node)) renderer.queueNode(node, shader=self._shader, transparent=True) # We also want to draw the axis for group nodes. if node.callDecoration("isGroup"): renderer.queueNode(scene.getRoot(), mesh=self._getAxisMesh(node)) renderer.queueNode(scene.getRoot(), mesh=node.getBoundingBoxMesh(), mode=Renderer.RenderLines)
def beginRendering(self): scene = self.getController().getScene() renderer = self.getRenderer() if not self._xray_shader: self._xray_shader = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "xray.shader")) self._xray_shader.setUniformValue( "u_color", Color(*Application.getInstance().getTheme().getColor( "xray").getRgb())) for node in BreadthFirstIterator(scene.getRoot()): # We do not want to render ConvexHullNode as it conflicts with the bottom of the X-Ray (z-fighting). if type(node) is ConvexHullNode: continue if not node.render(renderer): if node.getMeshData() and node.isVisible(): renderer.queueNode( node, shader=self._xray_shader, type=RenderBatch.RenderType.Solid, blend_mode=RenderBatch.BlendMode.Additive, sort=-10, state_setup_callback=lambda gl: gl.glDepthFunc( gl.GL_ALWAYS), state_teardown_callback=lambda gl: gl.glDepthFunc( gl.GL_LESS))
def getSelectFaceSupported(self) -> bool: """Get whether the select face feature is supported. :return: True if it is supported, or False otherwise. """ # Use a dummy postfix, since an equal version with a postfix is considered smaller normally. return Version(OpenGL.getInstance().getOpenGLVersion()) >= Version("4.1 dummy-postfix")
def render(self, renderer): if not ConvexHullNode.shader: ConvexHullNode.shader = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "transparent_object.shader")) ConvexHullNode.shader.setUniformValue("u_diffuseColor", self._color) ConvexHullNode.shader.setUniformValue("u_opacity", 0.6) if self.getParent(): if self.getMeshData() and isinstance( self._node, SceneNode) and self._node.callDecoration( "getBuildPlateNumber") == Application.getInstance( ).getMultiBuildPlateModel().activeBuildPlate: renderer.queueNode(self, transparent=True, shader=ConvexHullNode.shader, backface_cull=True, sort=-8) if self._convex_hull_head_mesh: renderer.queueNode(self, shader=ConvexHullNode.shader, transparent=True, mesh=self._convex_hull_head_mesh, backface_cull=True, sort=-8) return True
def render(self, renderer): if not ConvexHullNode.shader: ConvexHullNode.shader = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "transparent_object.shader")) ConvexHullNode.shader.setUniformValue("u_diffuseColor", self._color) ConvexHullNode.shader.setUniformValue("u_opacity", 0.1) batch = renderer.getNamedBatch("convex_hull_node") if not batch: batch = renderer.createRenderBatch(transparent=True, shader=ConvexHullNode.shader, backface_cull=True, sort=-8) renderer.addRenderBatch(batch, name="convex_hull_node") batch.addItem(self.getWorldTransformation(copy=False), self.getMeshData()) if self._convex_hull_head_mesh: # The full head. Rendered as a hint to the user: If this area overlaps another object A; this object # cannot be printed after A, because the head would hit A while printing the current object renderer.queueNode(self, shader=ConvexHullNode.shader, transparent=True, mesh=self._convex_hull_head_mesh, backface_cull=True, sort=-8) return True
def render(self) -> None: if not self._shader: try: self._shader = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "camera_distance.shader")) except InvalidShaderProgramError: Logger.error( "Unable to compile shader program: camera_distance.shader") return width, height = self.getSize() self._gl.glViewport(0, 0, width, height) self._gl.glClearColor(1.0, 1.0, 1.0, 0.0) self._gl.glClear(self._gl.GL_COLOR_BUFFER_BIT | self._gl.GL_DEPTH_BUFFER_BIT) # Create a new batch to be rendered batch = RenderBatch(self._shader) # Fill up the batch with objects that can be sliced. ` for node in DepthFirstIterator( self._scene.getRoot() ): #type: ignore #Ignore type error because iter() should get called automatically by Python syntax. if node.callDecoration( "isSliceable") and node.getMeshData() and node.isVisible(): batch.addItem(node.getWorldTransformation(), node.getMeshData()) self.bind() batch.render(self._scene.getActiveCamera()) self.release()
def __init__(self): super().__init__() self._qt_texture = QOpenGLTexture(QOpenGLTexture.Target2D) self._gl = OpenGL.getInstance().getBindingsObject() self._file_name = None self._image = None
def render(self, renderer): if not ConvexHullNode.shader: ConvexHullNode.shader = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "transparent_object.shader")) ConvexHullNode.shader.setUniformValue("u_diffuseColor", self._color) ConvexHullNode.shader.setUniformValue("u_opacity", 0.6) if self.getParent(): if self.getMeshData() and isinstance( self._node, SceneNode) and self._node.callDecoration( "getBuildPlateNumber") == Application.getInstance( ).getMultiBuildPlateModel().activeBuildPlate: # The object itself (+ adhesion in one-at-a-time mode) renderer.queueNode(self, transparent=True, shader=ConvexHullNode.shader, backface_cull=True, sort=-8) if self._convex_hull_head_mesh: # The full head. Rendered as a hint to the user: If this area overlaps another object A; this object # cannot be printed after A, because the head would hit A while printing the current object renderer.queueNode(self, shader=ConvexHullNode.shader, transparent=True, mesh=self._convex_hull_head_mesh, backface_cull=True, sort=-8) return True
def render(self): if not self._shader: self._shader = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "xray.shader")) batch = RenderBatch(self._shader, type=RenderBatch.RenderType.NoType, backface_cull=False, blend_mode=RenderBatch.BlendMode.Additive) for node in DepthFirstIterator(self._scene.getRoot()): if isinstance( node, CuraSceneNode) and node.getMeshData() and node.isVisible(): batch.addItem( node.getWorldTransformation(copy=False), node.getMeshData(), normal_transformation=node.getCachedNormalMatrix()) self.bind() self._gl.glDisable(self._gl.GL_DEPTH_TEST) batch.render(self._scene.getActiveCamera()) self._gl.glEnable(self._gl.GL_DEPTH_TEST) self.release()
def render(self, renderer): if not self._shader: self._shader = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "toolhandle.shader")) if self._auto_scale: active_camera = self._scene.getActiveCamera() if active_camera.isPerspective(): camera_position = active_camera.getWorldPosition() dist = (camera_position - self.getWorldPosition()).length() scale = dist / 400 else: view_width = active_camera.getViewportWidth() current_size = view_width + ( 2 * active_camera.getZoomFactor() * view_width) scale = current_size / view_width * 5 self.setScale(Vector(scale, scale, scale)) if self._line_mesh: renderer.queueNode(self, mesh=self._line_mesh, mode=RenderBatch.RenderMode.Lines, overlay=True, shader=self._shader) if self._solid_mesh: renderer.queueNode(self, mesh=self._solid_mesh, overlay=True, shader=self._shader) return True
def render(self, renderer) -> bool: if not self._shader: self._shader = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "toolhandle.shader")) if self._auto_scale: active_camera = self._scene.getActiveCamera() if active_camera.isPerspective(): camera_position = active_camera.getWorldPosition() dist = (camera_position - self.getWorldPosition()).length() scale = dist / 400 else: view_width = active_camera.getViewportWidth() current_size = view_width + ( 2 * active_camera.getZoomFactor() * view_width) scale = current_size / view_width * 5 self.setScale(Vector(scale, scale, scale)) if self._solid_mesh and self._tool: for position in [self._tool.getPointA(), self._tool.getPointB()]: self.setPosition( Vector(position.x(), position.y(), position.z())) renderer.queueNode(self, mesh=self._solid_mesh, overlay=False, shader=self._shader) return True
def _getOpenGLInfo(self): opengl_instance = OpenGL.getInstance() if not opengl_instance: self.data["opengl"] = { "version": "n/a", "vendor": "n/a", "type": "n/a" } return catalog.i18nc("@label", "not yet initialised<br/>") info = "<ul>" info += catalog.i18nc("@label OpenGL version", "<li>OpenGL Version: {version}</li>").format( version=opengl_instance.getOpenGLVersion()) info += catalog.i18nc("@label OpenGL vendor", "<li>OpenGL Vendor: {vendor}</li>").format( vendor=opengl_instance.getGPUVendorName()) info += catalog.i18nc("@label OpenGL renderer", "<li>OpenGL Renderer: {renderer}</li>").format( renderer=opengl_instance.getGPUType()) info += "</ul>" self.data["opengl"] = { "version": opengl_instance.getOpenGLVersion(), "vendor": opengl_instance.getGPUVendorName(), "type": opengl_instance.getGPUType() } return info
def beginRendering(self) -> None: scene = self.getController().getScene() renderer = self.getRenderer() if renderer is None: return if not self._ghost_shader: self._ghost_shader = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "color.shader")) theme = CuraApplication.getInstance().getTheme() if theme is not None: self._ghost_shader.setUniformValue( "u_color", Color(*theme.getColor("layerview_ghost").getRgb())) for node in DepthFirstIterator(scene.getRoot()): # We do not want to render ConvexHullNode as it conflicts with the bottom layers. # However, it is somewhat relevant when the node is selected, so do render it then. if type(node) is ConvexHullNode and not Selection.isSelected( cast(ConvexHullNode, node).getWatchedNode()): continue if not node.render(renderer): if (node.getMeshData()) and node.isVisible(): renderer.queueNode(node, transparent=True, shader=self._ghost_shader)
def beginRendering(self): scene = self.getController().getScene() renderer = self.getRenderer() if not self._xray_shader: self._xray_shader = OpenGL.getInstance().createShaderProgram( os.path.join( PluginRegistry.getInstance().getPluginPath("XRayView"), "xray.shader")) self._xray_shader.setUniformValue( "u_color", Color(*Application.getInstance().getTheme().getColor( "xray").getRgb())) for node in BreadthFirstIterator(scene.getRoot()): if not node.render(renderer): if node.getMeshData() and node.isVisible(): renderer.queueNode( node, shader=self._xray_shader, type=RenderBatch.RenderType.Solid, blend_mode=RenderBatch.BlendMode.Additive, sort=-10, state_setup_callback=lambda gl: gl.glDepthFunc( gl.GL_ALWAYS), state_teardown_callback=lambda gl: gl.glDepthFunc( gl.GL_LESS))
def event(self, event): if event.type == Event.ViewActivateEvent: if not self._xray_pass: # Currently the RenderPass constructor requires a size > 0 # This should be fixed in RenderPass's constructor. self._xray_pass = XRayPass.XRayPass(1, 1) self.getRenderer().addRenderPass(self._xray_pass) if not self._xray_composite_shader: self._xray_composite_shader = OpenGL.getInstance( ).createShaderProgram( os.path.join( PluginRegistry.getInstance().getPluginPath("XRayView"), "xray_composite.shader")) if not self._composite_pass: self._composite_pass = self.getRenderer().getRenderPass( "composite") self._old_layer_bindings = self._composite_pass.getLayerBindings() self._composite_pass.setLayerBindings( ["default", "selection", "xray"]) self._old_composite_shader = self._composite_pass.getCompositeShader( ) self._composite_pass.setCompositeShader( self._xray_composite_shader) if event.type == Event.ViewDeactivateEvent: self._composite_pass.setLayerBindings(self._old_layer_bindings) self._composite_pass.setCompositeShader(self._old_composite_shader)
def __init__(self): super().__init__() self._qt_texture = QOpenGLTexture(QOpenGLTexture.Target2D) self._qt_texture.setMinMagFilters(QOpenGLTexture.Linear, QOpenGLTexture.Linear) self._gl = OpenGL.getInstance().getBindingsObject()
def render(self): if not self._shader: self._shader = OpenGL.getInstance().createShaderProgram( os.path.join( PluginRegistry.getInstance().getPluginPath("XRayView"), "xray.shader")) batch = RenderBatch(self._shader, type=RenderBatch.RenderType.NoType, backface_cull=False, blend_mode=RenderBatch.BlendMode.Additive) for node in DepthFirstIterator(self._scene.getRoot()): if isinstance( node, CuraSceneNode) and node.getMeshData() and node.isVisible(): batch.addItem(node.getWorldTransformation(), node.getMeshData()) self.bind() self._gl.glDisable(self._gl.GL_DEPTH_TEST) batch.render(self._scene.getActiveCamera()) self._gl.glEnable(self._gl.GL_DEPTH_TEST) self.release()
def _updateRenderStorage(self): if self._width <= 0 or self._height <= 0: Logger.log("w", "Tried to create render pass with size <= 0") return self._fbo = OpenGL.getInstance().createFrameBufferObject( self._width, self._height)
def event(self, event): if event.type == Event.ViewActivateEvent: if not self._xray_pass: # Currently the RenderPass constructor requires a size > 0 # This should be fixed in RenderPass's constructor. self._xray_pass = XRayPass.XRayPass(1, 1) self.getRenderer().addRenderPass(self._xray_pass) if not self._xray_composite_shader: self._xray_composite_shader = OpenGL.getInstance().createShaderProgram(os.path.join(PluginRegistry.getInstance().getPluginPath("XRayView"), "xray_composite.shader")) theme = Application.getInstance().getTheme() self._xray_composite_shader.setUniformValue("u_background_color", Color(*theme.getColor("viewport_background").getRgb())) self._xray_composite_shader.setUniformValue("u_error_color", Color(*theme.getColor("xray_error").getRgb())) self._xray_composite_shader.setUniformValue("u_outline_color", Color(*theme.getColor("model_selection_outline").getRgb())) if not self._composite_pass: self._composite_pass = self.getRenderer().getRenderPass("composite") self._old_layer_bindings = self._composite_pass.getLayerBindings() self._composite_pass.setLayerBindings(["default", "selection", "xray"]) self._old_composite_shader = self._composite_pass.getCompositeShader() self._composite_pass.setCompositeShader(self._xray_composite_shader) if event.type == Event.ViewDeactivateEvent: self._composite_pass.setLayerBindings(self._old_layer_bindings) self._composite_pass.setCompositeShader(self._old_composite_shader)
def event(self, event): modifiers = QApplication.keyboardModifiers() ctrl_is_active = modifiers == Qt.ControlModifier if event.type == Event.KeyPressEvent and ctrl_is_active: if event.key == KeyEvent.UpKey: self.setLayer(self._current_layer_num + 1) return True if event.key == KeyEvent.DownKey: self.setLayer(self._current_layer_num - 1) return True if event.type == Event.ViewActivateEvent: # Make sure the LayerPass is created self.getLayerPass() Application.getInstance().globalContainerStackChanged.connect( self._onGlobalStackChanged) self._onGlobalStackChanged() if not self._layerview_composite_shader: self._layerview_composite_shader = OpenGL.getInstance( ).createShaderProgram( os.path.join( PluginRegistry.getInstance().getPluginPath( "LayerView"), "layerview_composite.shader")) theme = Application.getInstance().getTheme() self._layerview_composite_shader.setUniformValue( "u_background_color", Color(*theme.getColor("viewport_background").getRgb())) self._layerview_composite_shader.setUniformValue( "u_outline_color", Color(*theme.getColor("model_selection_outline").getRgb())) if not self._composite_pass: self._composite_pass = self.getRenderer().getRenderPass( "composite") self._old_layer_bindings = self._composite_pass.getLayerBindings( )[:] # make a copy so we can restore to it later self._composite_pass.getLayerBindings().append("layerview") self._old_composite_shader = self._composite_pass.getCompositeShader( ) self._composite_pass.setCompositeShader( self._layerview_composite_shader) Application.getInstance().setViewLegendItems( self._getLegendItems()) elif event.type == Event.ViewDeactivateEvent: self._wireprint_warning_message.hide() Application.getInstance().globalContainerStackChanged.disconnect( self._onGlobalStackChanged) if self._global_container_stack: self._global_container_stack.propertyChanged.disconnect( self._onPropertyChanged) self._composite_pass.setLayerBindings(self._old_layer_bindings) self._composite_pass.setCompositeShader(self._old_composite_shader) Application.getInstance().setViewLegendItems([])
def createMaterial(self): self._material = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "default.shader")) self._material.setUniformValue("u_ambientColor", Color(0.3, 0.3, 0.3, 1.0)) self._material.setUniformValue("u_diffuseColor", self._color) self._material.setUniformValue("u_specularColor", Color(1.0, 1.0, 1.0, 1.0)) self._material.setUniformValue("u_shininess", 50.0)
def render(self) -> None: if not self._shader: self._shader = OpenGL.getInstance().createShaderProgram( Resources.getPath(Resources.Shaders, "overhang.shader")) self._shader.setUniformValue("u_overhangAngle", 1.0) self._gl.glClearColor(0.0, 0.0, 0.0, 0.0) self._gl.glClear(self._gl.GL_COLOR_BUFFER_BIT | self._gl.GL_DEPTH_BUFFER_BIT) # Create a new batch to be rendered batch = RenderBatch(self._shader) # Fill up the batch with objects that can be sliced. ` for node in DepthFirstIterator(self._scene.getRoot()): if node.callDecoration( "isSliceable") and node.getMeshData() and node.isVisible(): uniforms = {} uniforms["diffuse_color"] = node.getDiffuseColor() batch.addItem(node.getWorldTransformation(), node.getMeshData(), uniforms=uniforms) self.bind() if self._camera is None: batch.render(Application.getInstance().getController().getScene(). getActiveCamera()) else: batch.render(self._camera) self.release()
def _updateTexture(self): if not self._global_container_stack or not OpenGL.getInstance(): return container = self._global_container_stack.findContainer({"platform_texture":"*"}) if container: texture_file = container.getMetaDataEntry("platform_texture") if texture_file: self._texture = OpenGL.getInstance().createTexture() self._texture.load(Resources.getPath(Resources.Images, texture_file)) if self._shader: self._shader.setTexture(0, self._texture) else: self._texture = None if self._shader: self._shader.setTexture(0, None)
def __init__(self, name: str, width: int, height: int, priority: int = 0) -> None: self._name = name #type: str self._width = width #type: int self._height = height #type: int self._priority = priority #type: int self._gl = OpenGL.getInstance().getBindingsObject() self._fbo = None #type: Optional[FrameBufferObject]
def __init__(self, width, height): super().__init__("layerview", width, height) self._layer_shader = None self._tool_handle_shader = None self._gl = OpenGL.getInstance().getBindingsObject() self._scene = Application.getInstance().getController().getScene() self._extruder_manager = ExtruderManager.getInstance() self._layer_view = None
def render(self, renderer): if not self._shader: self._shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "default.shader")) self._shader.setUniformValue("u_color", self._color) if self.getParent(): renderer.queueNode(self, transparent = True, shader = self._shader, backface_cull = True, sort = -8) if self._convex_hull_head_mesh: renderer.queueNode(self, shader = self._shader, transparent = True, mesh = self._convex_hull_head_mesh, backface_cull = True, sort = -8) return True
def beginRendering(self): scene = self.getController().getScene() renderer = self.getRenderer() if not self._shader: self._shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "object.shader")) for node in DepthFirstIterator(scene.getRoot()): if not node.render(renderer): if node.getMeshData() and node.isVisible(): renderer.queueNode(node, shader = self._shader)
def __init__(self, name, width, height, priority = 0): self._name = name self._width = width self._height = height self._priority = priority self._gl = OpenGL.getInstance().getBindingsObject() self._fbo = None self._updateRenderStorage()
def _updateRenderStorage(self) -> None: # On Mac OS X, this function may get called by a main window resize signal during closing. # This will cause a crash, so don't do anything when it is shutting down. import UM.Qt.QtApplication if UM.Qt.QtApplication.QtApplication.getInstance().isShuttingDown(): return if self._width <= 0 or self._height <= 0: Logger.log("w", "Tried to create render pass with size <= 0") return self._fbo = OpenGL.getInstance().createFrameBufferObject(self._width, self._height)
def render(self, renderer): if not self._shader: self._shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "platform.shader")) if self._texture: self._shader.setTexture(0, self._texture) else: self._updateTexture() if self.getMeshData(): renderer.queueNode(self, shader = self._shader, transparent = True, backface_cull = True, sort = -10) return True
def render(self, renderer): if not self.getMeshData(): return True if not self._shader: self._shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "default.shader")) self._grid_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "grid.shader")) theme = Application.getInstance().getTheme() self._grid_shader.setUniformValue("u_gridColor0", Color(*theme.getColor("buildplate").getRgb())) self._grid_shader.setUniformValue("u_gridColor1", Color(*theme.getColor("buildplate_alt").getRgb())) renderer.queueNode(self, mode = RenderBatch.RenderMode.Lines) renderer.queueNode(self, mesh = self._origin_mesh) renderer.queueNode(self, mesh = self._grid_mesh, shader = self._grid_shader, backface_cull = True) if self._disallowed_area_mesh: renderer.queueNode(self, mesh = self._disallowed_area_mesh, shader = self._shader, transparent = True, backface_cull = True, sort = -9) if self._error_mesh: renderer.queueNode(self, mesh=self._error_mesh, shader=self._shader, transparent=True, backface_cull=True, sort=-8) return True
def render(self, renderer): if not ConvexHullNode.shader: ConvexHullNode.shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "transparent_object.shader")) ConvexHullNode.shader.setUniformValue("u_diffuseColor", self._color) ConvexHullNode.shader.setUniformValue("u_opacity", 0.6) if self.getParent(): if self.getMeshData() and isinstance(self._node, SceneNode) and self._node.callDecoration("getBuildPlateNumber") == Application.getInstance().getMultiBuildPlateModel().activeBuildPlate: renderer.queueNode(self, transparent = True, shader = ConvexHullNode.shader, backface_cull = True, sort = -8) if self._convex_hull_head_mesh: renderer.queueNode(self, shader = ConvexHullNode.shader, transparent = True, mesh = self._convex_hull_head_mesh, backface_cull = True, sort = -8) return True
def render(self, renderer): if not ConvexHullNode.shader: ConvexHullNode.shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "transparent_object.shader")) ConvexHullNode.shader.setUniformValue("u_diffuseColor", self._color) ConvexHullNode.shader.setUniformValue("u_opacity", 0.6) if self.getParent(): if self.getMeshData(): renderer.queueNode(self, transparent = True, shader = ConvexHullNode.shader, backface_cull = True, sort = -8) if self._convex_hull_head_mesh: renderer.queueNode(self, shader = ConvexHullNode.shader, transparent = True, mesh = self._convex_hull_head_mesh, backface_cull = True, sort = -8) return True
def beginRendering(self): scene = self.getController().getScene() renderer = self.getRenderer() if not self._enabled_shader: self._enabled_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "overhang.shader")) if not self._disabled_shader: self._disabled_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "overhang.shader")) self._disabled_shader.setUniformValue("u_diffuseColor", [0.68, 0.68, 0.68, 1.0]) self._disabled_shader.setUniformValue("u_overhangAngle", math.cos(math.radians(0))) if Application.getInstance().getMachineManager().getWorkingProfile(): profile = Application.getInstance().getMachineManager().getWorkingProfile() if Preferences.getInstance().getValue("view/show_overhang"): angle = profile.getSettingValue("support_angle") if angle != None: self._enabled_shader.setUniformValue("u_overhangAngle", math.cos(math.radians(90 - angle))) else: self._enabled_shader.setUniformValue("u_overhangAngle", math.cos(math.radians(0))) #Overhang angle of 0 causes no area at all to be marked as overhang. else: self._enabled_shader.setUniformValue("u_overhangAngle", math.cos(math.radians(0))) for node in DepthFirstIterator(scene.getRoot()): if not node.render(renderer): if node.getMeshData() and node.isVisible(): # TODO: Find a better way to handle this #if node.getBoundingBoxMesh(): # renderer.queueNode(scene.getRoot(), mesh = node.getBoundingBoxMesh(),mode = Renderer.RenderLines) if hasattr(node, "_outside_buildarea"): if node._outside_buildarea: renderer.queueNode(node, shader = self._disabled_shader) else: renderer.queueNode(node, shader = self._enabled_shader) else: renderer.queueNode(node, material = self._enabled_shader) if node.callDecoration("isGroup"): renderer.queueNode(scene.getRoot(), mesh = node.getBoundingBoxMesh(),mode = Renderer.RenderLines)
def event(self, event): modifiers = QApplication.keyboardModifiers() ctrl_is_active = modifiers & Qt.ControlModifier shift_is_active = modifiers & Qt.ShiftModifier if event.type == Event.KeyPressEvent and ctrl_is_active: amount = 10 if shift_is_active else 1 if event.key == KeyEvent.UpKey: self.setLayer(self._current_layer_num + amount) return True if event.key == KeyEvent.DownKey: self.setLayer(self._current_layer_num - amount) return True if event.type == Event.ViewActivateEvent: # Make sure the SimulationPass is created layer_pass = self.getSimulationPass() self.getRenderer().addRenderPass(layer_pass) # Make sure the NozzleNode is add to the root nozzle = self.getNozzleNode() nozzle.setParent(self.getController().getScene().getRoot()) nozzle.setVisible(False) Application.getInstance().globalContainerStackChanged.connect(self._onGlobalStackChanged) self._onGlobalStackChanged() if not self._simulationview_composite_shader: self._simulationview_composite_shader = OpenGL.getInstance().createShaderProgram(os.path.join(PluginRegistry.getInstance().getPluginPath("SimulationView"), "simulationview_composite.shader")) theme = Application.getInstance().getTheme() self._simulationview_composite_shader.setUniformValue("u_background_color", Color(*theme.getColor("viewport_background").getRgb())) self._simulationview_composite_shader.setUniformValue("u_outline_color", Color(*theme.getColor("model_selection_outline").getRgb())) if not self._composite_pass: self._composite_pass = self.getRenderer().getRenderPass("composite") self._old_layer_bindings = self._composite_pass.getLayerBindings()[:] # make a copy so we can restore to it later self._composite_pass.getLayerBindings().append("simulationview") self._old_composite_shader = self._composite_pass.getCompositeShader() self._composite_pass.setCompositeShader(self._simulationview_composite_shader) elif event.type == Event.ViewDeactivateEvent: self._wireprint_warning_message.hide() Application.getInstance().globalContainerStackChanged.disconnect(self._onGlobalStackChanged) if self._global_container_stack: self._global_container_stack.propertyChanged.disconnect(self._onPropertyChanged) self._nozzle_node.setParent(None) self.getRenderer().removeRenderPass(self._layer_pass) self._composite_pass.setLayerBindings(self._old_layer_bindings) self._composite_pass.setCompositeShader(self._old_composite_shader)
def _initialize(self): supports_vao = OpenGLContext.supportsVertexArrayObjects() # fill the OpenGLContext.properties Logger.log("d", "Support for Vertex Array Objects: %s", supports_vao) OpenGL.setInstance(OpenGL()) self._gl = OpenGL.getInstance().getBindingsObject() self._default_material = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "default.shader")) self._render_passes.add(DefaultPass(self._viewport_width, self._viewport_height)) self._render_passes.add(SelectionPass(self._viewport_width, self._viewport_height)) self._render_passes.add(CompositePass(self._viewport_width, self._viewport_height)) buffer = QOpenGLBuffer(QOpenGLBuffer.VertexBuffer) buffer.create() buffer.bind() buffer.allocate(120) data = numpy.array([ -1.0, -1.0, 0.0, 1.0, 1.0, 0.0, -1.0, 1.0, 0.0, -1.0, -1.0, 0.0, 1.0, -1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0 ], dtype = numpy.float32).tostring() buffer.write(0, data, len(data)) buffer.release() self._quad_buffer = buffer self._initialized = True self.initialized.emit()
def _getOpenGLInfo(self): opengl_instance = OpenGL.getInstance() if not opengl_instance: self.data["opengl"] = {"version": "n/a", "vendor": "n/a", "type": "n/a"} return catalog.i18nc("@label", "Not yet initialized<br/>") info = "<ul>" info += catalog.i18nc("@label OpenGL version", "<li>OpenGL Version: {version}</li>").format(version = opengl_instance.getOpenGLVersion()) info += catalog.i18nc("@label OpenGL vendor", "<li>OpenGL Vendor: {vendor}</li>").format(vendor = opengl_instance.getGPUVendorName()) info += catalog.i18nc("@label OpenGL renderer", "<li>OpenGL Renderer: {renderer}</li>").format(renderer = opengl_instance.getGPUType()) info += "</ul>" self.data["opengl"] = {"version": opengl_instance.getOpenGLVersion(), "vendor": opengl_instance.getGPUVendorName(), "type": opengl_instance.getGPUType()} return info
def render(self): if not self._shader: self._shader = OpenGL.getInstance().createShaderProgram(os.path.join(PluginRegistry.getInstance().getPluginPath("XRayView"), "xray.shader")) batch = RenderBatch(self._shader, type = RenderBatch.RenderType.NoType, backface_cull = False, blend_mode = RenderBatch.BlendMode.Additive) for node in DepthFirstIterator(self._scene.getRoot()): if type(node) is SceneNode and node.getMeshData() and node.isVisible(): batch.addItem(node.getWorldTransformation(), node.getMeshData()) self.bind() self._gl.glDisable(self._gl.GL_DEPTH_TEST) batch.render(self._scene.getActiveCamera()) self._gl.glEnable(self._gl.GL_DEPTH_TEST) self.release()
def render(self, renderer): if not self._shader: self._shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "toolhandle.shader")) if self._auto_scale: camera_position = self._scene.getActiveCamera().getWorldPosition() dist = (camera_position - self.getWorldPosition()).length() scale = dist / 400 self.setScale(Vector(scale, scale, scale)) if self._line_mesh: renderer.queueNode(self, mesh = self._line_mesh, mode = RenderBatch.RenderMode.Lines, overlay = True, shader = self._shader) if self._solid_mesh: renderer.queueNode(self, mesh = self._solid_mesh, overlay = True, shader = self._shader) return True
def beginRendering(self): scene = self.getController().getScene() renderer = self.getRenderer() if not self._shader: self._shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "mesh.shader")) for node in DepthFirstIterator(scene.getRoot()): if not node.render(renderer): if node.getMeshData() and node.isVisible(): if node.getDecorator(PathResultDecorator.PathResultDecorator): renderer.queueNode(node, mode=RenderBatch.RenderMode.Lines, overlay=True) else: renderer.queueNode(node, shader=self._shader) if node.callDecoration("isGroup"): renderer.queueNode(scene.getRoot(), mesh=node.getBoundingBoxMesh(), mode=RenderBatch.RenderMode.LineLoop)