def initOgreWindow(self, renderWindowName, cameraName):
        self.renderParameters = og.NameValuePairList()

        if platform.system() == "Windows" or platform.system() == "MAC":
            hwnd = int(self.winId())
            self.renderParameters['externalWindowHandle'] = str(hwnd)
        else:
            win = str(int(self.winId()))
            self.renderParameters['parentWindowHandle'] = win
示例#2
0
    def _get_window_params(self):
        """
        Encapsulates the platform specific part of the window creation, grabing
        the windows handle and transforming them for Ogre.
        """
        params = Ogre.NameValuePairList()

        if '__WXGTK__' == wx.Platform:
            from ram.gui.util import get_window_handle_str
            params['externalWindowHandle'] = get_window_handle_str(self)
        elif '__WXMSW__' == wx.Platform:
            params['externalWindowHandle'] = str(self.GetHandle())
        else:
            raise Exception('%s no yet supported' % wx.Platform)

        return params
示例#3
0
    def __init__(self, config, deps):
        core.Subsystem.__init__(self, config.get('name', 'Simulation'))
        Simulation.SIMULATION = self
        self._windowListener = WindowListener(self.windowClosed)

        self._simulation = simulation.Simulation(config)
        self._root = ogre.Root.getSingleton()

        self._debugOutput = config.get('debugOutput', False)

        # Load data file
        self._guiFileName = self._getGUIFileName(config)
        guiData = {}
        try:
            stream = file(self._guiFileName, 'r')
            guiData = yaml.load(stream)
            stream.close()
        except (IOError, yaml.YAMLError):
            # File does not exist, ignore
            pass

        # Load settings and create screen
        simGUICfg = guiData.get('SIM', {})
        width = simGUICfg.get("windowWidth", 800)
        height = simGUICfg.get("windowHeight", 600)
        top = simGUICfg.get("windowTop", 100)
        left = simGUICfg.get("windowLeft", 100)
        params = ogre.NameValuePairList()
        params['top'] = str(top)
        params['left'] = str(left)

        self._window = self._root.createRenderWindow("Simulator", width,
                                                     height, False, params)

        self._debug = config.get('debug', False)
        self._backgrounded = False

        # Load Scenes and grab the main one
        self._simulation.create_all_scenes()
        self.scene = self._simulation.get_scene('Main')

        # Input System
        self._inputForwarder = input.OISInputForwarder( \
            {}, self._simulation.input_system, self._window)

        event.register_handlers({'SCREENSHOT': self._onScreenshot})

        # Determine camera settings
        margin = 0.005
        width = 0.5 - 1.5 * margin
        height = width * 0.75
        top = 1 - margin - height
        mainHeight = 1 - 2 * margin - height
        if not config.get('vehicleView'):
            mainHeight = 1

        # Setup viewport
        camera = self.scene.get_camera('Main').camera
        camera.setAutoAspectRatio(True)
        viewport = self._window.addViewport(camera, height=mainHeight)
        viewport._updateDimensions()

        if config.get('vehicleView'):
            robot = self.scene._robots['Tortuga']
            forwardCamera = Simulation._createCamera(robot, '_forward',
                                                     (0.5, 0, 0), (1, 0, 0))
            viewport = self._window.addViewport(forwardCamera,
                                                ZOrder=1,
                                                top=top,
                                                left=margin,
                                                height=height,
                                                width=width)
            viewport._updateDimensions()

            downwardCamera = Simulation._createCamera(robot, '_downward',
                                                      (0.5, 0, -0.1),
                                                      (0, 0, -1))
            viewport = self._window.addViewport(downwardCamera,
                                                ZOrder=2,
                                                top=top,
                                                left=0.5 + margin / 2,
                                                height=height,
                                                width=width)
            viewport._updateDimensions()

        self._simulation.start()

        time.sleep(1)
        if self._debug:
            ogrenewt.Debugger.getSingleton().init(self.scene.scene_mgr)