def remove_resource(self, resource):
     # Remove it from the TextureManager
     TextureManager.get_instance().remove_texture(resource)
     
     
     
     
Example #2
0
    def render(self, material, mesh, transform):
        # self.set_uniform_data('material.ambient', material.ambient)
        # self.set_uniform_data('material.diffuse', material.diffuse)
        # self.set_uniform_data('material.specular', material.specular)
        # self.set_uniform_data('material.shininess', material.shininess)

        # this is a kind of roundabout of accessing this
        world_mat = transform.world_matrix
        #world_mat.transpose()
        self.set_uniform_data('model', world_mat)

        texture = TextureManager.get_instance().get_texture_by_name( material.texture )
        if texture is not None:
            self.set_uniform_data('diffuse_texture', texture)

        if self.attributes_valid():
            self.enable_attribute_arrays()
        
        if mesh.vertex_buffer.is_setup:
            with mesh.vertex_buffer as vb:
                if self.attributes_valid():
                    glVertexAttribPointer(self.get_attribute_location("position"), *vb.GetVertexAttribute())
                    glVertexAttribPointer(self.get_attribute_location("normal"), *vb.GetNormalAttribute())
                    glVertexAttribPointer(self.get_attribute_location("colour"), *vb.GetColourAttribute())
                    glVertexAttribPointer(self.get_attribute_location("texture_coordinate"), *vb.GetTexCoordAttribute())
                
                glDrawElements(GL_TRIANGLES, vb.count, GL_UNSIGNED_SHORT, vb.indices)
        
        if self.attributes_valid():
            self.disable_attribute_arrays()

        #QuitEvent().send()
    def process_resource(self, filename, name):
        
#        new_texture = None
        # Does the Texture already exist in the Texture Manager
        new_texture = TextureManager.get_instance().get_texture_by_filename(filename)
#        for texture in TextureManager.get_instance().textures:
#            if texture.filename == filename:
#                new_texture = texture
#                break
        
        # If the texture isn't in the texture manager
        if new_texture is None:
            # Load the image
            new_texture = Texture(filename=filename, name=name)
            
            # Add it to the TextureManager
            TextureManager.get_instance().add_texture(new_texture)
            
            # Create a Resource object that also contains the Texture object within the data property
#            new_resource = Texture(filename=filename)
        
        # Return the new Resource
        return new_texture
Example #4
0
 def texture(self, new_tex):
     the_texture = None
     if isinstance(new_tex, Texture):
         the_texture = new_tex
     
     elif isinstance(new_tex, str):
         # Get Texture from TextureManager
         the_texture = TextureManager.get_instance().get_texture(new_tex)
         
     if the_texture is not None:
         self._tex_obj = the_texture
         self._tex_name = the_texture.name
     else:
         Logger.Log("Can't find texture: %s" % new_tex)
Example #5
0
    def _gen_texture(self, address, resolution=None):
        texture_name = None

        # If the a texture for the address has already been generated
        if address in self._generated_textures:
            texture_name = self._generated_textures[address]

        # Otherwise generate a new texture
        else:

            face = CubeSphereMap.get_address_face(address)
            level = len(address)

            name = "planet_texture"
            size = self._increments #256

            if not resolution is None:
                size = resolution

            data = None
            format_size = 4
            pitch = size * format_size
            format = "RGBA"

            #b = datetime.now()

            # Generate the data for the texture
            
            #perlin = Perlin(12345)

            # Generate sphere coordinates for the address
            # verts = []
            # for x in range(size):
            #     o = ""
            #     x /= float(size)

            #     for y in range(size):
            #         y /= float(size)
            #         # verts.append( Vector3(x, y, 0.5) )
            #         coord = CubeSphereMap.get_sphere_vector(x, y, face) * self._radius
            #         # #print coord
            #         verts.append( coord )

            #         o += " (%1.2f, %1.2f)" % (x, y)
            #verts = self._gen_verts(address)
            # mesh = self._generated_meshes[address]
            # verts = mesh.vertices
                
                #print o

            #ignoring faces
            #print verts
            # as image data is loaded from bottom-left to top-right vertex data
            # needs to be transformed as it is generated top-left to bottom-right

            # t_data = []
            # for x in xrange(size-1, -1, -1):
            #     row_start = x * size
            #     row_end = row_start + size
            #     t_data += verts[row_start:row_end]

            # for x in range(size):
            #     row_start = x * size
            #     row_end = row_start + size

                # o = ""
                # for v in verts[row_start:row_end]:
                #     o += " (%1.2f, %1.2f, %1.2f)" % (v.x, v.y, v.z)

            # Generate noise
            #data = [self._noise.ridged_multi_fractal3(v[0], v[1], v[2], 0, 1.0) for v in t_data]
            #data = [self._noise.ridged_multi_fractal3(v[0], v[1], v[2], 0, 1.0) for v in t_data]
            
            # data = [perlin.noise3(v.x, v.x, v.x) * 255.0 for v in verts]

            # first_scale = 8 * self._octaves

            #second_scale = 0.5 * self._octaves
            
            # data = []

            noise = self._generated_noise[address]

            # t_data = []
            # for x in xrange(size-1, -1, -1):
            #     row_start = x * size
            #     row_end = row_start + size
            #     t_data += noise[row_start:row_end]

            # for x in range(size):
            #     row_start = x * size
            #     row_end = row_start + size

            # noise = t_data

            colour_data = []

            #for v in verts:
            # for n in noise:
            for y in range(self._increments):#,-1,-1):
                nv = []
                for x in range(self._increments):#,-1,-1):

                    n = noise[x][y]
                    # # convert the height to a colour value
                    # #height = ( (v.magnitude() - self._radius) / self._max_height ) * 255.0

                    #nv.append(n)

                    # if n > 1.0:
                    #     print "n: %3.2f x: %d y: %d" % ( n, x, y)

                    height = (n * 128.0) + 128.0

                    # #height = 150.0
                    # #print height

                    colour = Preset.white

                    if 200 >= height >= 150:
                        colour = Preset.green
                    elif 150 > height > 100:
                        colour = Preset.yellow
                    elif 100 >= height:
                        colour = Preset.blue
                    
                    # if 50 > height:
                    #     colour = Preset.blue
                    # else:
                    #     colour = Preset.red

                    # if x == 0 or x == self._increments-1:
                    #     colour = Preset.yellow

                    # if y == 0 or y == self._increments-1:
                    #     colour = Preset.green
                    
                    # colour = Preset.red

                    # colour = colour.tinted(Preset.green, (y/float(size)))
                    # colour = colour.tinted(Preset.blue, (x/float(size)))

                    colour_data += [colour.r * 255.0, colour.g * 255.0, colour.b * 255.0, colour.a * 255.0]
                # s = ""
                # for n in noise[x]:
                #     s += "\t%0.3f," % n
                # print s

            #e = datetime.now() - b

            #print "%s Tex Colours Gen time: %3.5f" % (address, e.total_seconds())#(e.seconds +  (e.microseconds / 1000000.0) ) )

            # colour_data = []
            # for n in noise:
            
            #     nv.append(n)

            #     height = (n * 128.0) + 128.0

            #     if 100 > height:
            #         colour = Preset.blue
            #     else:
            #         colour = Preset.red

            #     colour_data += [colour.r * 255.0, colour.g * 255.0, colour.b * 255.0, colour.a * 255.0]

            #b = datetime.now()

            # Transform noise to colour data
            array_data = numpy.array(colour_data, 'f')

            # array_data = numpy.random.random_integers(low=0,
            #                                           high=255,
            #                                           size = (size * size, format_size))

            #array_data *= 255
            # array_data[:,3] = 255
            array_data.shape = -1
            tex_data = (GLubyte * array_data.size)(*array_data.astype('u1'))

            #test_plane = SceneManager.get_instance().current_scene.root.transform.get_child_with_name("test_plane")

            texture_name = "planet_texture_%s" % address
            
            new_planet_texture = GeneratedTexture(name=texture_name, width=size, height=size)
            new_planet_texture.wrapped = False
            new_planet_texture.smoothed = True

            new_planet_texture.set_data(format, pitch, tex_data)

            TextureManager.get_instance().add_texture(new_planet_texture)
            
            #test_plane.node.renderer.material.texture = "planet_texture"
            
            #e = datetime.now() - b

            #print "%s Tex Gen Vid card copy time: %3.5f" % (address, e.total_seconds())#(e.seconds +  (e.microseconds / 1000000.0) ) )

            #new_planet_texture.image.save(texture_name+'.png')

            self._generated_textures[address] = texture_name

        return texture_name
Example #6
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())
            
            # Get the name
            name = None
            if "name" in node.attrib:
                name = node.attrib["name"]

            # If the texture is referenced by filename
            if "filename" in node.attrib:
                
                # Load the texture
                filename = node.attrib["filename"]
                texture = ResourceManager.get_instance().process_resource(filename, name)                    
            
            # If the texture is just a reference, retrieve it from the TextureManager for assignment
            if texture is None and name is not None:
                texture = TextureManager.get_instance().get_texture_by_name(name)
            
            # If the current parent is a Material node, set the material node's texture 
            if not parent is None:
                if isinstance(parent, BaseMaterial) and not texture is None:
                    parent.texture = texture
        
#        elif node.tag == "shader":
#            pass
        
        # Unknown XML tag    
        else:
            self._log.Log("WARNING: Unknown XML Tag: " + node.tag)
        
        # If it's not a node that has already had it's children processed
        if not node.tag in ["children","scripts","material"]: