Exemple #1
0
    def __init__(self, type, lane):
        self.previous_car = None
        self.in_map = True
        self.following = None
        self.car_normal_image = image.create(50, 50, image.SolidColorImagePattern(color=(0, 0, 255, 255)))
        self.car_emergency_image = image.create(50, 50, image.SolidColorImagePattern(color=(255, 0, 0, 255)))
        self.lane = lane
        self.type = type
        self.from_direction = lane.get_from()
        self.appear_time = time.time()
        self.removed = False
        self.has_started = False
        self.state = "running"
        self.has_set_occupied = False
        self.has_unset_occupied = False
        # self.stoppable = True
        if self.type is "normal":
            super(Car, self).__init__(self.car_normal_image)
        elif self.type is "emergency":
            super(Car, self).__init__(self.car_emergency_image)

        if self.from_direction is "north":
            self.position = (350, 850)
        if self.from_direction is "east":
            self.position = (850, 450)
        if self.from_direction is "south":
            self.position = (450, -50)
        if self.from_direction is "west":
            self.position = (-50, 350)

        pyglet.clock.schedule_interval(self.traffic_light_control, 0.01)
Exemple #2
0
    def draw_road(self):

        road_image_1 = image.create(200, 800, image.SolidColorImagePattern(color=(190, 190, 190, 255)))
        road_image_2 = image.create(800, 200, image.SolidColorImagePattern(color=(190, 190, 190, 255)))
        road_1 = Sprite(road_image_1, position=(400, 400))
        road_2 = Sprite(road_image_2, position=(400, 400))
        self.add(road_1)
        self.add(road_2)
        self.draw_line()
  def gen_cube_map(self):
    
    self._right = image.create(self._image_size, self._image_size, image.CheckerImagePattern()) 
    self._back = image.create(self._image_size, self._image_size, image.CheckerImagePattern())
    self._left = image.create(self._image_size, self._image_size, image.CheckerImagePattern()) 
    # self._front = image.create(self._image_size, self._image_size, image.CheckerImagePattern())
    # self._top = image.create(self._image_size, self._image_size, image.CheckerImagePattern()) 
    # self._bottom = image.create(self._image_size, self._image_size, image.CheckerImagePattern())

    # # TOP
    # face = 0
    # start = datetime.now()
    # self._set_image_data(self._top, self.multi_proc_image(face))
    # el = datetime.now() - start
    # print "Face: %d Elapsed: %d.%3.0f" % (face, el.seconds, el.microseconds / 1000.0)
    
    # BACK
    face = 1
    start = datetime.now()
    self._set_image_data(self._back, self.multi_proc_image(face))
    el = datetime.now() - start
    print "Face: %d Elapsed: %d.%3.0f" % (face, el.seconds, el.microseconds / 1000.0)
    
    # RIGHT
    face = 2
    start = datetime.now()
    self._set_image_data(self._right, self.multi_proc_image(face))
    el = datetime.now() - start
    print "Face: %d Elapsed: %d.%3.0f" % (face, el.seconds, el.microseconds / 1000.0)
    
    # # BOTTOM
    # face = 3
    # start = datetime.now()
    # self._set_image_data(self._bottom, self.multi_proc_image(face))
    # el = datetime.now() - start
    # print "Face: %d Elapsed: %d.%3.0f" % (face, el.seconds, el.microseconds / 1000.0)
    
    # # FRONT
    # face = 4
    # start = datetime.now()
    # self._set_image_data(self._front, self.multi_proc_image(face))
    # el = datetime.now() - start
    # print "Face: %d Elapsed: %d.%3.0f" % (face, el.seconds, el.microseconds / 1000.0)
    
    # LEFT
    face = 5
    start = datetime.now()
    self._set_image_data(self._left, self.multi_proc_image(face))
    el = datetime.now() - start
    print "Face: %d Elapsed: %d.%3.0f" % (face, el.seconds, el.microseconds / 1000.0)
    def __init__(self,position):

        self.signal = "red"
        self.red_image = image.create(50,50,image.SolidColorImagePattern(color=(255,0,0,255)))
        self.green_image = image.create(50,50,image.SolidColorImagePattern(color=(50,205,50,255)))

        super(TrafficLight,self).__init__(self.red_image)
        if position is "north":
            self.position = (250,550)
        if position is "east":
            self.position = (550,550)
        if position is "south":
            self.position = (550, 250)
        if position is "west":
            self.position = (250,250)
Exemple #5
0
    def __init__(self, w, h, *elements, **kwargs):
        self._elements = []
        self._namedElements = {}
        
        data = (ctypes.c_ubyte * w * h * 4)()
        
        pitch = w * 4
        surface = cairo.ImageSurface.create_for_data (data, cairo.FORMAT_ARGB32, w, h, pitch);
        context = cairo.Context(surface)
        self.surface = surface
        self.context = context
        self.size = w, h
        self.pitch = pitch

        for e in elements:
            if issubclass(e.__class__, UiElement):
                self.add(e)
                e.drawContext()
        
        imgdata = Image.frombuffer('RGBA', (w, h), surface.get_data(),
                                   'raw', 'BGRA', 0, 1).tostring('raw', 'RGBA', 0, 1)
        
        img = image.create(w, h)
        img.set_data('RGBA', pitch, imgdata)
        
        super(CairoUI, self).__init__(img)
        
        self.needRedraw = False
        self.hasPointer = False
        self.interactive = kwargs.get('interactive', True)
        
        self.schedule(self.drawElements)
Exemple #6
0
    def __init__(self, w, h, *elements, **kwargs):
        self._elements = []
        self._namedElements = {}

        data = (ctypes.c_ubyte * w * h * 4)()

        pitch = w * 4
        surface = cairo.ImageSurface.create_for_data(data, cairo.FORMAT_ARGB32,
                                                     w, h, pitch)
        context = cairo.Context(surface)
        self.surface = surface
        self.context = context
        self.size = w, h
        self.pitch = pitch

        for e in elements:
            if issubclass(e.__class__, UiElement):
                self.add(e)
                e.drawContext()

        imgdata = Image.frombuffer('RGBA', (w, h), surface.get_data(), 'raw',
                                   'BGRA', 0, 1).tostring('raw', 'RGBA', 0, 1)

        img = image.create(w, h)
        img.set_data('RGBA', pitch, imgdata)

        super(CairoUI, self).__init__(img)

        self.needRedraw = False
        self.hasPointer = False
        self.interactive = kwargs.get('interactive', True)

        self.schedule(self.drawElements)
Exemple #7
0
    def __init__(self, theApp):
        ''' theApp: refernecja do obiektu aplikacji. Potrzebne przy dodawaniu obiektu nasłuchującego wejścia. '''

        self.__theApp = theApp                                              # obiekt zarządzający aplikacją
        self.__objects = []                                                 # lista obiektów w świecie

        self.__spriteManager     = SpriteManager()                           # menadżer sprite'ów
        self.__collisionManager  = CollisionManager(self.__spriteManager)    # menadżer kolizji
        self.__objectFactory     = self.__create_object_factory(self.__spriteManager) # fabryka obiektów
        self.__levelManager      = LevelManager(self.__objectFactory,self.__spriteManager)  # menadżer poziomów
        self.__backgroundManager = BackgroundManager( levelManager = self.__levelManager )
        self.__backgroundManager.set_window_coords( self.__theApp.get_window_coords() )
        self.__backgroundManager.set_window_draw_dim( self.__theApp.get_window_draw_dim() )
        self.__levelManager.set_window_coords( self.__theApp.get_window_coords() )
        self.__levelManager.set_window_draw_dim( self.__theApp.get_window_draw_dim() )

        if not self.__levelManager.load_level("demo_level"):
            assert True, "Tworzenie świata nie powiodło się. Nie można wczytać poziomu."

        const.renderTextureSize = (512,256)                # rozmiary tekstury, do której będziemy renderować
        self.__renderTexture = image.create( *const.renderTextureSize ).get_texture()

        # Dodaj obiekt helikoptera i jeepa do gry
        #
        # FIXME: jeep?
        #
        self.add_object( self.__create_heli() )
Exemple #8
0
    def __init__(self, width=400, height=300, **kwds):
        super(BufferedAutogeneratedTerrain, self).__init__(width, height, **kwds)
        self.buffer_image = image.create(self.boundingbox.width, self.boundingbox.height).create_texture(image.Texture)

        for i in range(0, self.boundingbox.width):
            y = self.heights[i]
            region = self.terrain_graphic.get_region(0, self.terrain_graphic.height - y, self.terrain_graphic.width, y)
            self.buffer_image.blit_into(region, int(i), 0, 0)
Exemple #9
0
 def _make_mini_graphic(self, width):
     heights = self._generate_mini_heights(width)
     graphic = image.create(width, 10).create_texture(image.Texture)
     y_scale = 20.0 / self.boundingbox.height
     bar = self._mini_terrain_graphic
     for x in xrange(len(heights)):
         y = int(math.ceil(heights[x] * y_scale))
         region = bar.get_region(0, bar.height - y, bar.width, y)
         graphic.blit_into(region, x, 0, 0)
     return graphic.image_data
Exemple #10
0
    def __init__(self, name=None, width=128, height=128, format="RGBA", data=None):
        Texture.__init__(self, "", name)
        self._size_x = width
        self._size_y = height
        self._format = format
        self._pyglet_image = image.create(self._size_x, self._size_y, image.CheckerImagePattern())
        self._opengl_id = self._pyglet_image.get_texture().id

        if data is not None:
            self.set_data(self._format, len(self._format) * self._size_x, data) 
        self._loaded = True
Exemple #11
0
    def __init__(self, request, test_data):
        super(ImageTestFixture, self).__init__(request)
        self.test_data = test_data

        self.show_checkerboard = True
        self.show_triangle_left = False
        self.show_text = True
        self.left_texture = None
        self.right_texture = None

        self.checkerboard = image.create(32, 32, image.CheckerImagePattern())
    def test_main(self):
        width, height = 200, 200
        self.window = w = Window(width, height, visible=False)
        w.push_handlers(self)

        self.texture = image.create(32, 32, image.CheckerImagePattern()).texture

        w.set_visible()
        while not (w.has_exit or self.has_exit):
            w.dispatch_events()
        w.close()
Exemple #13
0
    def test_main(self):
        width, height = 200, 200
        self.window = w = Window(width, height, visible=False)
        w.push_handlers(self)

        self.texture = image.create(32, 32,
                                    image.CheckerImagePattern()).texture

        w.set_visible()
        while not (w.has_exit or self.has_exit):
            w.dispatch_events()
        w.close()
Exemple #14
0
 def _make_mini_graphic(self, width=None):
     if width is None:
         total_width = puit.gamemaster.scrollarea.width
     else:
         total_width = width
     graphic = image.create(total_width, 10).create_texture(image.Texture)
     x_scale = total_width / float(self.boundingbox.width)
     y_scale = 20.0 / self.boundingbox.height
     for part in self.get_parts():
         part_width = part.boundingbox.width
         part_mini_width = int(round(part_width * x_scale))
         part_graphic = part.get_mini_graphic(part_mini_width)
         part_pos_x = int(round(part.boundingbox.left * x_scale))
         part_pos_y = int(round(part.boundingbox.bottom * y_scale))
         graphic.blit_into(part_graphic, part_pos_x, part_pos_y, 0)
     return graphic
    def test_save(self):
        self.window = w = self.create_window()
        w.push_handlers(self)

        self.screen = image.get_buffer_manager().get_color_buffer()
        self.checkerboard = image.create(32, 32, image.CheckerImagePattern())

        self.load_texture()

        if self.alpha:
            glEnable(GL_BLEND)
            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

        w.set_visible()
        while not (w.has_exit or self.has_exit):
            w.dispatch_events()
        w.close()
Exemple #16
0
    def test_save(self):
        self.window = w = self.create_window()
        w.push_handlers(self)

        self.screen = image.get_buffer_manager().get_color_buffer()
        self.checkerboard = image.create(32, 32, image.CheckerImagePattern())

        self.load_texture()

        if self.alpha:
            glEnable(GL_BLEND)
            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

        w.set_visible()
        while not (w.has_exit or self.has_exit):
            w.dispatch_events()
        w.close()
Exemple #17
0
    def test_load(self):
        width, height = 800, 600
        self.window = w = Window(width, height, visible=False)
        w.push_handlers(self)

        self.screen = image.get_buffer_manager().get_color_buffer()
        self.checkerboard = image.create(32, 32, image.CheckerImagePattern())

        self.load_image()
        if self.image:
            self.texture = self.image.texture

        if self.alpha:
            glEnable(GL_BLEND)
            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

        w.set_visible()
        while not (w.has_exit or self.has_exit):
            w.dispatch_events()
        w.close()
Exemple #18
0
    def test_load(self):
        width, height = 800, 600
        self.window = w = Window(width, height, visible=False)
        w.push_handlers(self)

        self.screen = image.get_buffer_manager().get_color_buffer()
        self.checkerboard = image.create(32, 32, image.CheckerImagePattern())

        self.load_image()
        if self.image:
            self.texture = self.image.texture

        if self.alpha:
            glEnable(GL_BLEND)
            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

        w.set_visible()
        while not (w.has_exit or self.has_exit):
            w.dispatch_events()
        w.close()
Exemple #19
0
    def __init__(self,
                 tex_name,
                 tile_width,
                 tile_height,
                 game_state,
                 xpos=0,
                 ypos=0,
                 group=None,
                 health=3,
                 move_pattern=unlucky,
                 move_params=(),
                 name='enemy',
                 gold=1,
                 exp=1,
                 hitsound='bandit_hit',
                 damage=1):
        super().__init__(tex_name,
                         tile_width,
                         tile_height,
                         game_state,
                         xpos=xpos,
                         ypos=ypos,
                         group=group,
                         damage=damage,
                         health=health,
                         name=name,
                         hitsound=hitsound)

        self.is_guard = 'guard' in tex_name
        if type(move_pattern) == str:
            self.move_pattern = patterns[move_pattern](self, *move_params)
        else:
            self.move_pattern = move_pattern(self, *move_params)
        self.game.enemies.add(self)
        self.stats[G] = gold
        self.stats[EXP] = exp
        self.healthbar = Sprite(create(24, 4, SolidColorImagePattern(RED)),
                                x=self.x,
                                y=self.y,
                                batch=self.batch,
                                group=self.game.groups[1])
  def generate_image(self):

    #print int(image.get_image_data().get_data("RGBA",1024)[0])
    #print image.get_image_data().get_data("RGBA",1024)


    self._size = 512
    format_size = 4
    # data = []
    # for x in xrange(size * format_size):
    #   for y in xrange(size * format_size):
    #     if (x * y) + 1 % format_size == 0:
    #       data.append(255)  
    #     else:
    #       data.append(int(random() * 255))

    # d = struct.pack('B'*len(data), *data)
    # #tex_data = (GLubyte * 1)( *d )

    # imd = image.ImageData(size, size, 'RGBA', d)

    # im.blit_from(imd, 0, 0)

    start = datetime.now()

    self._back = image.create(self._image_size, self._image_size, image.CheckerImagePattern())

    # data = numpy.random.random_integers(low=0,
    #                                     high=1,
    #                                     size = (size * size, format_size))

    perlin_data = self.single_threaded_image()
    #perlin_data = self.multi_threaded_image()
    #perlin_data = self.multi_proc_image(0)


    el = datetime.now() - start

    print "Elapsed: %d.%3.0f" % ( el.seconds, el.microseconds / 1000.0)

    self._set_image_data(self._back, perlin_data)
Exemple #21
0
 def drawElements(self, dt):
     surface = self.surface
     context = self.context
     
     context.set_source_rgba(0, 0, 0, 0)
     context.set_operator(cairo.OPERATOR_SOURCE)
     context.paint()
     
     w, h = self.size
     pitch = self.pitch
     
     for i in self._elements:
         i.drawContext()
     
     imgdata = Image.frombuffer('RGBA', (w , h),
     surface.get_data(), 'raw', 'BGRA', 0, 1).tostring('raw', 'RGBA', 0, 1)
     
     img = image.create(w, h)
     img.set_data('RGBA', pitch, imgdata)
     
     self.image = img
Exemple #22
0
    def drawElements(self, dt):
        surface = self.surface
        context = self.context

        context.set_source_rgba(0, 0, 0, 0)
        context.set_operator(cairo.OPERATOR_SOURCE)
        context.paint()

        w, h = self.size
        pitch = self.pitch

        for i in self._elements:
            i.drawContext()

        imgdata = Image.frombuffer('RGBA', (w, h), surface.get_data(), 'raw',
                                   'BGRA', 0, 1).tostring('raw', 'RGBA', 0, 1)

        img = image.create(w, h)
        img.set_data('RGBA', pitch, imgdata)

        self.image = img
Exemple #23
0
    def __init__(self, height=84, width=84, resize_ratio=1):
        from pyglet.gl import glEnable, glBlendFunc
        from pyglet.gl import GL_BLEND, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA
        from pyglet import window, image
        from pygarrayimage.arrayimage import ArrayInterfaceImage
        self.width = width
        self.height = height
        self.resize_ratio = resize_ratio
        self.window = window.Window(width=int(width * resize_ratio),
                                    height=int(height * resize_ratio),
                                    visible=False,
                                    resizable=True)
        self.arr = np.zeros(
            (int(height * resize_ratio), int(width * resize_ratio)),
            dtype=np.uint8)
        self.aii = ArrayInterfaceImage(self.arr)
        self.img = self.aii.texture

        checks = image.create(32, 32, image.CheckerImagePattern())
        self.background = image.TileableTexture.create_for_image(checks)
        self.window.set_visible()

        glEnable(GL_BLEND)
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
Exemple #24
0
def play(frames,
         delay=0,
         magnify=1,
         background=None,
         blit_position=None,
         show_frame_number=True):

    w = window.Window(visible=False, resizable=True)

    arr = numpy.zeros([100, 100], dtype=numpy.uint8)
    aii = ArrayInterfaceImage(arr)
    img = aii.texture

    if background is None:
        checks = image.create(32, 32, image.CheckerImagePattern())
        background = image.TileableTexture.create_for_image(checks)
        background_tiled = True
    else:
        if background.dtype != np.uint8:
            'converting background to uint8'
            background = np.array(background, dtype=np.uint8) * 255
        background_aii = ArrayInterfaceImage(background)
        background = background_aii.texture
        background_tiled = False

    if background_tiled:
        w.width = img.width
        w.height = img.height
        w.set_visible()
    else:
        w.width = background.width
        w.height = background.height
        w.set_visible()

    LIBGL_ALWAYS_SOFTWARE = 1
    glEnable(GL_BLEND)
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

    for i, f in enumerate(frames):
        arr = f

        if arr is not None:
            if arr.dtype != np.uint8:
                'converting'
                arr = np.array(arr, dtype=np.uint8) * 255

            if magnify != 1:
                newshape = [arr.shape[0] * magnify, arr.shape[1] * magnify]
                arr = nim.rebin(arr, newshape)
            try:
                aii.view_new_array(arr)
            except:  # size changed
                print 'size changed!'
                #w.width = arr.shape[1]
                #w.height = arr.shape[0]
                aii = ArrayInterfaceImage(arr)

            img = aii.texture
            w.dispatch_events()
            w.clear()

            if background_tiled:
                background.blit_tiled(0, 0, 0, 100, 100)  #w.width, w.height)
            else:
                background.blit(0, 0, 0)

            # add some overlays:
            if show_frame_number:
                s = 'frame: ' + str(i)
                label = pyglet.text.Label(s,
                                          font_name='courier',
                                          font_size=36,
                                          x=10,
                                          y=10)
                label.draw()

            if blit_position is None:
                img.blit(0, 0, 0)
            else:
                img.blit(blit_position[i][1], blit_position[i][0], 0)

#frame_number_text.draw()
            if 0:
                r = arr.shape[0] / 2.
                body_axis = npmovie.kalmanobj.long_axis[f]
                wing_axis = npmovie.kalmanobj.wingaxisR[f]
                wing_center = npmovie.kalmanobj.wingcenterR[f]
                #print wing_center, wing_axis
                if mode == 'wingimgR':
                    print f, uframe.wingimgR.sum()
                pyglet.graphics.draw(
                    2, pyglet.gl.GL_LINES,
                    ('v2i',
                     (int(r), int(r), int(body_axis[1] * 10 * magnify) +
                      int(r), int(body_axis[0] * 10 * magnify) + int(r))))
                try:
                    pyglet.graphics.draw(
                        2, pyglet.gl.GL_LINES,
                        ('v2i', (int(r), int(r), int(wing_center[1] * magnify),
                                 int(wing_center[0] * magnify))))
                    pyglet.graphics.draw(1, pyglet.gl.GL_POINTS,
                                         ('v2i',
                                          (int(wing_center[1] * magnify),
                                           int(wing_center[0] * magnify))))
                    pass
                except:
                    pass

            w.flip()

            time.sleep(delay)  # slow down the playback

    w.close()
Exemple #25
0
def draw_square(x, y, size, colour = (255, 255, 255, 0)):
    # Creates the image.
    img = image.create(size, size, image.SolidColorImagePattern(colour))
    # Draws the image on the canvas. x, y is the top-corner of the image.
    img.blit(x, y)
Exemple #26
0
def play(frames, delay=0, magnify=1, background=None, blit_position=None, show_frame_number=True):

    w = window.Window(visible=False, resizable=True)
    
    arr = numpy.zeros([100,100], dtype=numpy.uint8)
    aii = ArrayInterfaceImage(arr)
    img = aii.texture

    if background is None:
        checks = image.create(32, 32, image.CheckerImagePattern())
        background = image.TileableTexture.create_for_image(checks)
        background_tiled = True
    else:
        if background.dtype != np.uint8:
            'converting background to uint8'
            background = np.array(background, dtype=np.uint8)*255
        background_aii = ArrayInterfaceImage(background)
        background = background_aii.texture
        background_tiled = False
        
    if background_tiled:
        w.width = img.width
        w.height = img.height
        w.set_visible()
    else:
        w.width = background.width
        w.height = background.height
        w.set_visible()
    
    LIBGL_ALWAYS_SOFTWARE = 1
    glEnable(GL_BLEND)
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
    
    
    for i, f in enumerate(frames):
        arr = f
                        
        if arr is not None:
            if arr.dtype != np.uint8:
                'converting'
                arr = np.array(arr, dtype=np.uint8)*255
                
            if magnify != 1:
                newshape = [arr.shape[0]*magnify, arr.shape[1]*magnify]
                arr = nim.rebin(arr, newshape)
            try:
                aii.view_new_array(arr)
            except: # size changed
                print 'size changed!'
                #w.width = arr.shape[1]
                #w.height = arr.shape[0]
                aii = ArrayInterfaceImage(arr)
                
            img = aii.texture
            w.dispatch_events()
            w.clear()
            
            
            if background_tiled:
                background.blit_tiled(0, 0, 0, 100, 100) #w.width, w.height)
            else:
                background.blit(0,0,0)
                
            # add some overlays:
            if show_frame_number:
                s = 'frame: ' + str(i)
                label = pyglet.text.Label(s,
                        font_name='courier',
                        font_size=36,
                        x=10, y=10)
                label.draw()

                
            if blit_position is None:
                img.blit(0, 0, 0)
            else:
                img.blit(blit_position[i][1], blit_position[i][0], 0)
                
            
			    
			    #frame_number_text.draw()
            if 0:
                r = arr.shape[0]/2.
                body_axis = npmovie.kalmanobj.long_axis[f]
                wing_axis = npmovie.kalmanobj.wingaxisR[f]
                wing_center = npmovie.kalmanobj.wingcenterR[f]
                #print wing_center, wing_axis
                if mode == 'wingimgR':
                    print f, uframe.wingimgR.sum() 
                pyglet.graphics.draw(2, pyglet.gl.GL_LINES,('v2i', (int(r), int(r), int(body_axis[1]*10*magnify)+int(r), int(body_axis[0]*10*magnify)+int(r))))
                try:        
                    pyglet.graphics.draw(2, pyglet.gl.GL_LINES,('v2i', (int(r), int(r), int(wing_center[1]*magnify), int(wing_center[0]*magnify))))
                    pyglet.graphics.draw(1, pyglet.gl.GL_POINTS,('v2i', (int(wing_center[1]*magnify), int(wing_center[0]*magnify))))
                    pass
                except:
                    pass
            
            
            w.flip()
            
            time.sleep(delay) # slow down the playback
    
    w.close()
Exemple #27
0
dialog windows

slider
button
text input
drop list
check box
"""

main_menu = ['play', 'help', 'opions', 'exit']

import pyglet
from pyglet.gl import *
from pyglet.image import create, SolidColorImagePattern

image = create(128, 32, SolidColorImagePattern((0x00, 0x00, 0x00, 0x7F)))
texture = image.get_texture()

theme = {'text_color':       (0x00, 0xFF, 0xFF, 0xFF),
         'border_width':      2,
         'border_color':     (0.0, 1.0, 1.0, 0.2),
         'background_color': (0.0, 0.0, 0.0, 0.6)}

g_tasks = []

visible_objects = []

def on_mouse_press(x, y, button, modifiers):
	for o in visible_objects:
		if o.hitTest((x, y)):
			return o.press(button, modifiers)
            # test 2D array
            arr.shape = height, width
    else:
        # test constructor from PIL image
        import Image

        if Image.VERSION < "1.1.6":
            # new PIL necessary for __array_interface__
            raise ValueError("Need Image (PIL) version 1.1.6 ")
        arr = Image.open(filename)
        # arr = numpy.asarray( pil_image )
    aii = ArrayInterfaceImage(arr)

    img = aii.texture

    checks = image.create(32, 32, image.CheckerImagePattern())
    background = image.TileableTexture.create_for_image(checks)

    w.width = img.width
    w.height = img.height
    w.set_visible()

    glEnable(GL_BLEND)
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

    i = 0
    while not w.has_exit:
        w.dispatch_events()

        background.blit_tiled(0, 0, 0, w.width, w.height)
        img.blit(0, 0, 0)
Exemple #29
0
 def _make_mini_graphic(self, width):
     return image.create(width, 1, image.SolidColorImagePattern(self._colour))
Exemple #30
0
+#........................#+
+#........................#+
+##########.....###########+
+++++++++++SSSSS++++++++++++
'''.strip()
field_rows = [line.strip() for line in field_cells.splitlines()]

cw = ch = 16
hw = hh = 8
map_height = len(field_rows)
map_width = len(field_rows[0])

win = window.Window(map_width*cw, map_height*ch)

# load / create image resources
blank_image = image.create(cw, ch, image.SolidColorImagePattern((200,)*4))
wall_image = image.create(cw, ch, image.SolidColorImagePattern((100,)*4))
highlight_image = image.create(cw, ch,
    image.SolidColorImagePattern((255, 255, 255, 100)))
enemy_image = image.create(hw, hh,
    image.SolidColorImagePattern((255, 50, 50, 255)))
enemy_image.anchor_x = hw//2
enemy_image.anchor_y = hh//2
turret_image = resource.image('basic-gun.png')
turret_image.anchor_x = 8
turret_image.anchor_y = 8
bullet_image = image.create(3, 3, image.SolidColorImagePattern((0,0,0,255)))
bullet_image.anchor_x = 1
bullet_image.anchor_y = 1

def distance(x1, y1, x2, y2):
               [18, 19, 20],
               [21, 22, 23],
               [26, 25, 24],
               [29, 28, 27],
               [30, 31, 32],
               [33, 34, 35]
               ]

    device.set_camera(eye=vector([0, 0, -3, 1]),
                      at=vector([0.23, 0, 0, 1]),
                      up=vector([0, 1, 0, 1]))

    # the rotate degree
    rotate_degree = 1

    frame = image.create(device.width, device.height)
    fps_display = pyglet.clock.ClockDisplay()

    # produce texture, chess board
    texture = np.ones((256, 256, 4), dtype='uint8') * 255
    grid_size = 32
    for i in range(grid_size):
        for j in [j * 2 for j in range(grid_size / 2)]:
            texture[i * grid_size:i * grid_size + grid_size,
            (j + (i % 2)) * grid_size:(j + (i % 2)) * grid_size + grid_size, :] = vector([1, 128, 255, 255])

    device.set_texture(texture)
    device.add_dir_light(vector([0, 0, 3]),
                         vector([0.05, 0.05, 0.05]),
                         vector([0.7, 0.7, 0.7]))
Exemple #32
0
               tex_coor=vector([0.0, 1.]),
               rhw=1)
    ]

    indices = [[0, 1, 2], [3, 4, 5], [8, 7, 6], [11, 10, 9], [14, 13, 12],
               [17, 16, 15], [18, 19, 20], [21, 22, 23], [26, 25, 24],
               [29, 28, 27], [30, 31, 32], [33, 34, 35]]

    device.set_camera(eye=vector([0, 0, -3, 1]),
                      at=vector([0.23, 0, 0, 1]),
                      up=vector([0, 1, 0, 1]))

    # the rotate degree
    rotate_degree = 1

    frame = image.create(device.width, device.height)
    fps_display = pyglet.clock.ClockDisplay()

    # produce texture, chess board
    texture = np.ones((256, 256, 4), dtype='uint8') * 255
    grid_size = 32
    for i in range(grid_size):
        for j in [j * 2 for j in range(grid_size / 2)]:
            texture[i * grid_size:i * grid_size + grid_size,
                    (j + (i % 2)) * grid_size:(j + (i % 2)) * grid_size +
                    grid_size, :] = vector([1, 128, 255, 255])

    device.set_texture(texture)
    device.add_dir_light(vector([0, 0, 3]), vector([0.05, 0.05, 0.05]),
                         vector([0.7, 0.7, 0.7]))
Exemple #33
0
        if depth==1 and 1:
            # test 2D array
            arr.shape = height,width
    else:
        # test constructor from PIL image
        import Image
        if Image.VERSION < '1.1.6':
            # new PIL necessary for __array_interface__
            raise ValueError("Need Image (PIL) version 1.1.6 ")
        arr = Image.open(filename)
        #arr = numpy.asarray( pil_image )
    aii = ArrayInterfaceImage(arr)

    img = aii.texture

    checks = image.create(32, 32, image.CheckerImagePattern())
    background = image.TileableTexture.create_for_image(checks)

    w.width = img.width
    w.height = img.height
    w.set_visible()

    glEnable(GL_BLEND)
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

    i=0
    while not w.has_exit:
        w.dispatch_events()
        
        background.blit_tiled(0, 0, 0, w.width, w.height)
        img.blit(0, 0, 0)
Exemple #34
0
# data = []
# for x in xrange(size * format_size):
#   for y in xrange(size * format_size):
#     if (x * y) + 1 % format_size == 0:
#       data.append(255)  
#     else:
#       data.append(int(random() * 255))

# d = struct.pack('B'*len(data), *data)
# #tex_data = (GLubyte * 1)( *d )

# imd = image.ImageData(size, size, 'RGBA', d)

# im.blit_from(imd, 0, 0)

im = image.create(size, size, image.CheckerImagePattern())

data = numpy.random.random_integers(low=0,
                                    high=1,
                                    size = (size * size, format_size))

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

# dim = image.ImageData(size,size, "RGBA", tex_data, pitch )
im.set_data("RGBA", pitch, tex_data)
Exemple #35
0
def main():
	oGameWindow = pyglet.window.Window(I_WIDTH, I_HEIGHT)

	# 顶点

	# 索引
	lIndice = [
		[0, 1, 2],
		[3, 4, 5],

		[6, 7, 8],
		[9, 10, 11],

		[12, 13, 14],
		[15, 16, 17],

		[18, 19, 20],
		[21, 22, 23],

		[24, 25, 26],
		[27, 28, 29],

		[30, 31, 32],
		[33, 34, 35],
	]

	# lVertex = [
	# 	CVertex(vector([0, 2, 0, 1]), vector([1, 0, 0, 0]), vector([0, 0])),
	# 	CVertex(vector([0, 0, 2, 1]), vector([1, 0, 0, 0]), vector([1, 0])),
	# 	CVertex(vector([0, -2, 0, 1]), vector([1, 0, 0, 0]), vector([0, 1])),
	# ]
	#
	# lIndice = [
	# 	[0, 1, 2],
	# ]

	# 纹理(棋盘格)
	mTexture = np.ones((256, 256, 4), dtype="uint8")
	grid_size = 32
	for i in range(8):
		# 每隔1个格子
		for j in [x * 2 for x in range(4)]:
			mTexture[i * grid_size: (i + 1) * grid_size, (j + i % 2) * grid_size: (j + i % 2 + 1) * grid_size, :] = vector([1. / 255, 128. / 255, 1, 1])

	oDevice = device.CDevice(I_WIDTH, I_HEIGHT, mTexture)
	oCameraMgr = camera.CMgr()
	oCamera = oCameraMgr.GetCamera(camera.TYPE_NORMAL)

	oCamera.SetEye(vector([-4, 0, 0, 1]))
	oCamera.SetLookAt(vector([-2, 0, 0, 1]))
	oCamera.SetUp(vector([0, 1, 0, 0]))
	oCamera.SetAspect(1.0)
	oCamera.SetFar(300.0)

	oLight = light.CPointLight(1)
	oLightMgr = light.CMgr()
	oLightMgr.AddLight(oLight)

	oFrame = image.create(I_WIDTH, I_HEIGHT)

	@oGameWindow.event
	def on_draw():
		"""
		每帧调用
		"""

		oGameWindow.clear()
		oDevice.ClearFrameBuffer(vector([128., 33., 78., 1]))
		oDevice.ClearZBuffer()

		global g_fDegree
		mModelTrans = rtmath.getRotateMatrix(vector([1, 1, 1, 0]), g_fDegree / np.pi * 180)
		oDevice.SetModelTrans(mModelTrans)
		g_fDegree += 0.0005
		g_fDegree %= 180

		oDevice.DrawMesh(lVertex, lIndice)

		mFrameBuffer = oDevice.GetFramebuffer()

		oFrame.set_data("RGBA", I_WIDTH * 4, mFrameBuffer.tostring())
		oFrame.blit(0, 0)

	pyglet.clock.schedule_interval(lambda dt: None, 1 / 60.0)
	pyglet.app.run()
+#........................#+
+#........................#+
+##########.....###########+
+++++++++++SSSSS++++++++++++
'''.strip()
field_rows = [line.strip() for line in field_cells.splitlines()]

cw = ch = 16
hw = hh = 8
map_height = len(field_rows)
map_width = len(field_rows[0])

win = window.Window(map_width * cw, map_height * ch)

# load / create image resources
blank_image = image.create(cw, ch, image.SolidColorImagePattern((200, ) * 4))
wall_image = image.create(cw, ch, image.SolidColorImagePattern((100, ) * 4))
highlight_image = image.create(
    cw, ch, image.SolidColorImagePattern((255, 255, 255, 100)))
enemy_image = image.create(hw, hh,
                           image.SolidColorImagePattern((255, 50, 50, 255)))
enemy_image.anchor_x = hw // 2
enemy_image.anchor_y = hh // 2
turret_image = resource.image('basic-gun.png')
turret_image.anchor_x = 8
turret_image.anchor_y = 8
bullet_image = image.create(3, 3, image.SolidColorImagePattern((0, 0, 0, 255)))
bullet_image.anchor_x = 1
bullet_image.anchor_y = 1

Exemple #37
0
def play_npmovie(npmovie, delay=0, magnify=1, mode="uimg", frames=None, framerange=None, print_frames=False):

    w = window.Window(visible=False, resizable=True)

    arr = numpy.zeros([60, 60], dtype=numpy.uint8)
    aii = ArrayInterfaceImage(arr)
    img = aii.texture
    w.width = img.width
    w.height = img.height
    w.set_visible()

    checks = image.create(32, 32, image.CheckerImagePattern())
    background = image.TileableTexture.create_for_image(checks)

    glEnable(GL_BLEND)
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

    if frames is None:
        if framerange is not None:
            start = framerange[0]
            stop = framerange[1]
            if stop == -1:
                stop = len(npmovie.uframes)
            frames = np.arange(start, stop)
        else:
            frames = np.arange(1, len(npmovie.uframes))

    for f in frames:
        uframe = npmovie.uframes[f]
        if uframe.uimg is not None:
            try:
                if mode == "uimg":
                    arr = uframe.uimg
                if mode == "legs":
                    arr = uframe.legs
                if mode == "body":
                    arr = uframe.body
                if mode == "wings":
                    arr = uframe.wings
                if mode == "absdiff":
                    arr = uframe.absdiff
                if mode == "wingimg2":
                    arr = uframe.wingimg2
                if mode == "wingimgR":
                    arr = uframe.wingimgR
                if mode == "wingimgL":
                    arr = uframe.wingimgL
                if mode == "wingimg":
                    arr = uframe.wingimg
                if mode == "flysegs":
                    arr = uframe.flysegs
                if mode == "diffthresh":
                    arr = uframe.diffthresh
                if mode == "full":
                    arr = npmovie.background
                    arr[uframe.indices[0] : uframe.indices[1], uframe.indices[2] : uframe.indices[3]] = uframe.uimg
            except:
                arr = None

            if arr is not None:
                if arr.dtype != np.uint8:
                    "converting"
                    arr = np.array(arr, dtype=np.uint8) * 255

                if magnify != 1:
                    newshape = [arr.shape[0] * magnify, arr.shape[1] * magnify]
                    arr = nim.rebin(arr, newshape)
                try:
                    aii.view_new_array(arr)
                except:  # size changed
                    w.width = arr.shape[1]
                    w.height = arr.shape[0]
                    aii = ArrayInterfaceImage(arr)

                img = aii.texture

                w.dispatch_events()

                background.blit_tiled(0, 0, 0, w.width, w.height)
                img.blit(0, 0, 0)

                # add some overlays:
                r = arr.shape[0] / 2.0
                body_axis = npmovie.kalmanobj.long_axis[f]

                if 0:
                    wing_axis = npmovie.kalmanobj.wingaxisR[f]
                    wing_center = npmovie.kalmanobj.wingcenterR[f]
                    # print wing_center, wing_axis
                    if mode == "wingimgR":
                        print f, uframe.wingimgR.sum()
                    pyglet.graphics.draw(
                        2,
                        pyglet.gl.GL_LINES,
                        (
                            "v2i",
                            (
                                int(r),
                                int(r),
                                int(body_axis[1] * 10 * magnify) + int(r),
                                int(body_axis[0] * 10 * magnify) + int(r),
                            ),
                        ),
                    )
                    try:
                        pyglet.graphics.draw(
                            2,
                            pyglet.gl.GL_LINES,
                            ("v2i", (int(r), int(r), int(wing_center[1] * magnify), int(wing_center[0] * magnify))),
                        )
                        pyglet.graphics.draw(
                            1,
                            pyglet.gl.GL_POINTS,
                            ("v2i", (int(wing_center[1] * magnify), int(wing_center[0] * magnify))),
                        )
                        pass
                    except:
                        pass
                w.flip()

                time.sleep(delay)  # slow down the playback

    w.close()