Ejemplo n.º 1
0
    def __init__(self, pos=Vector3(0,0,0), radius=150.0, density=16): #6.328
        Node.__init__(self)
        
        self._name = "planet_root"

        self.transform.position = pos

        # The mesh density
        self._density = density
        
        # The camera position in sphere-space coordinates
        self._camera_pos = pos
        self._camera_pos_sc = None
        self._radius = radius
        self._horizon = 0.0
        
        self._max_depth = 8
        
        #self._camera_gizmo = WireSphere(radius=0.1)
        #self.transform.add_child(self._camera_gizmo.transform)
        
        self._camera_gizmo = GizmoManager.draw_sphere(Vector3(), radius=0.2)
        
        # The maximum height of the sphere surface (above the radius)
        self._max_height = (radius * 0.05) #0.02
        self._split_factor = 1.1  #16
        self._split_power = 1.1 #1.25
        
        self._horizon = 0
        
        self._ui = PlanetSphereDebugWindow()
        
        # Number splits this frame
        self._num_splits = 0
        # Max number of splits per frame
        self._max_splits = 8
        
#        pos = self.transform.position
#        pos.y += 0.1
#        self.transform.position.y = 1.0
#        self._line = Line(Vector3(0,1,0), Vector3(0, 0, 0), 5.0)
#        self.transform.add_child(self._line.transform)

        self._line = GizmoManager.draw_line(Vector3(-1,0,0), Vector3(0,0,0), 5.0)
        
#        self._cube_pos = Line(self.transform.position, Vector3(0, 0, 0), 5.0)
#        self.transform.add_child(self._cube_pos.transform)
        
        self._camera = None
        self._last_camera_pos = None
        self._last_time = datetime.now()
        
        self._generator = SphereSurface(self._density, self._radius, self._max_height)

        # Create the faces of the planet
        self._gen_faces()
Ejemplo n.º 2
0
 def init(self, width, height, title):
     WindowRenderer.init(self, width, height, title)
     
     self._ui_manager = UIManager.get_instance()
     
     # Create the ShaderManager
     self._shader_manager = ShaderManager.get_instance()
     
     # Get the GizmoManager
     self._gizmo_manager = GizmoManager.get_instance()
     
     # Initialise OpenGL Display and set the indicator for initialisation completion
     self._has_initialised = self.setup_3d()
Ejemplo n.º 3
0
    def __init__(self):
        # Load Configuration settings
        ConfigurationManager.load_configuration()

        #Start Logger
        method = Settings.get('LoggerSettings','method')
        filename = Settings.get('LoggerSettings','filename')
        to_console = Settings.get('LoggerSettings','log_to_console')
        Logger.Configure(method, filename, to_console)
        Logger.Log('Initialising Core Systems')
        
        # The order of initialisation in this function is extremely important
        # as it determines the order in which classes will receive events.
        # For instance it is important that input is processed
        
        # Start Event System so it can receive new listeners when the
        # classes below are initialised 
        self._event_manager = EventManager.get_instance()
        
        #Register Core Event Listener for detecting quit
        self._core_listener = CoreListener(False)
        
        # Initialise Time
        self._time = Time.get_instance()
        
        # Create a Scene
        self._scene = SceneManager.get_instance()
        self._scene.init()
        
        #Start Render System
        self._render_manager = RenderManager.get_instance()

        self._render_manager.init( Settings.get('DisplaySettings','resolution')[0],
                                   Settings.get('DisplaySettings','resolution')[1],
                                   Settings.get('DisplaySettings','window_title')
                                 )
        
        # Setup the framework callbacks
        self._framework = FrameworkManager.framework()
        self._framework.setup = self.setup
        self._framework.run_loop = self.update
        self._framework.on_draw = self._render_manager.draw
        self._framework.on_shutdown = self.shutdown
                
        # Setup Frame Start/End Events
        self._frame_start = FrameStarted()
        self._frame_end = FrameEnded()
        
        #Get the Texture Manager
        self._texture_manager = TextureManager.get_instance()
        
        # Start the ShaderManager
        self._shader_manager = ShaderManager.get_instance()
        
        # Start Scripting System
        self._script_manager = ScriptManager.get_instance()
        
        # Start the UI Manager and setup the MainUI
        self._ui_manager = UIManager.get_instance()
        self._main_ui = MainUI()
        
        # Start the GizmoManager system
        self._gizmo_manager = GizmoManager.get_instance()
        
        # Configure the ResourceManager
        self._resource_manager = ResourceManager.get_instance()
        # enable Image Loading
        self._resource_manager.add_handler(ImageResourceHandler())
        # enable Scene Loading
        self._resource_manager.add_handler(SceneResourceHandler())
        # enable Wavefront Obj Loading
        self._resource_manager.add_handler(WavefrontResourceHandler())
Ejemplo n.º 4
0
    def _vis_frustum(self, show):

        if show:
            if self._gizmos is None:
                # Create gizmos
                # Frustum Plane Gizmos
                self._gizmos = []

                self._topg = GizmoManager.draw_plane(Vector3(), size=15.0, colour=Preset.blue)
                self._bottomg = GizmoManager.draw_plane(Vector3(), size=15.0, colour=Preset.red)
                self._leftg = GizmoManager.draw_plane(Vector3(), size=15.0, colour=Preset.orange)
                self._rightg = GizmoManager.draw_plane(Vector3(), size=15.0, colour=Preset.purple)

                self._gizmos.append(self._topg)
                self._gizmos.append(self._bottomg)
                self._gizmos.append(self._rightg)
                self._gizmos.append(self._leftg)

                # Lines
                self._tl = GizmoManager.draw_line(Vector3(), colour=Preset.red)
                self._tr = GizmoManager.draw_line(Vector3(), colour=Preset.red)
                self._bl = GizmoManager.draw_line(Vector3(), colour=Preset.red)
                self._br = GizmoManager.draw_line(Vector3(), colour=Preset.red)

                self._gizmos.append(self._tl)
                self._gizmos.append(self._tr)
                self._gizmos.append(self._bl)
                self._gizmos.append(self._br)
                
                self._oforward = GizmoManager.draw_line(Vector3(), colour=Preset.blue)
                self._oup = GizmoManager.draw_line(Vector3(), colour=Preset.green)
                self._oright = GizmoManager.draw_line(Vector3(), colour=Preset.red)
                self._gizmos.append(self._oforward)
                self._gizmos.append(self._oup)
                self._gizmos.append(self._oright)

                #self._cam_pos = GizmoManager.draw_cube(Vector3(), 1.0, 1.0, 1.0)
            
                self._tl.transform.position = self._verts[self.NTL]
                self._tl.line_to(self._verts[self.FTL])
                
                self._tr.transform.position = self._verts[self.NTR]
                self._tr.line_to(self._verts[self.FTR])
                
                self._bl.transform.position = self._verts[self.NBL]
                self._bl.line_to(self._verts[self.FBL])
                
                self._br.transform.position = self._verts[self.NBR]
                self._br.line_to(self._verts[self.FBR])

                # Transform orientation
                self._oforward.transform.position = self._transform.position.copy()
                self._oforward.direction = self._transform.forward
                self._oforward.length = 3.0
                
                self._oup.transform.position = self._transform.position.copy()
                self._oup.direction = self._transform.up
                self._oup.length = 3.0
                
                self._oright.transform.position = self._transform.position.copy()
                self._oright.direction = self._transform.right
                self._oright.length = 3.0

                # Frustum plane visualisation
                self._topg.transform.position = self._transform.position
                self._topg.normal = self._top.n

                self._bottomg.transform.position = self._transform.position
                self._bottomg.normal = self._bottom.n

                self._leftg.transform.position = self._transform.position
                self._leftg.normal = self._left.n

                self._rightg.transform.position = self._transform.position
                self._rightg.normal = self._right.n
        else:
            if not self._gizmos is None:
                for giz in self._gizmos:
                    GizmoManager.remove_gizmo(giz)
                self._gizmos = None