コード例 #1
0
class MainWidget2(BaseWidget):
    def __init__(self):
        super(MainWidget2, self).__init__()

        # create a clock and a tempo map
        self.clock = Clock()
        self.tempo_map = SimpleTempoMap(120)

        # and text to display our status
        self.label = topleft_label()
        self.add_widget(self.label)

    def on_key_down(self, keycode, modifiers):
        if keycode[1] == 'c':
            self.clock.toggle()

    def on_update(self):

        time = self.clock.get_time()
        tick = self.tempo_map.time_to_tick(time)
        bpm = self.tempo_map.get_tempo()

        self.label.text = 'time:{:.2f}\n'.format(time)
        self.label.text += tick_str(tick) + '\n'
        self.label.text += 'bpm:{}\n'.format(bpm)
        self.label.text += 'c: toggle clock\n'
コード例 #2
0
    def __init__(self,
                 norm,
                 sandbox,
                 mixer,
                 client,
                 client_id,
                 block_handler,
                 tempo=60):
        self.norm = norm
        self.module_name = 'TempoCursor'
        self.sandbox = sandbox
        self.mixer = mixer
        self.client = client
        self.cid = client_id
        self.block_handler = block_handler

        self.tempo = tempo
        self.clock = Clock()
        self.tempo_map = SimpleTempoMap(bpm=self.tempo)

        self.touch_points = {}

        self.cursors = AnimGroup()
        self.sandbox.add(self.cursors)

        self.gui = CursorGUI(norm,
                             pos=self.norm.nt((20, 300)),
                             beat_callback=self.update_touch_points)

        self.delete_mode = {}
コード例 #3
0
ファイル: session.py プロジェクト: jrburga/JamOn
    def __init__(self, other_members, tempo, bars, divs, inst_set):
        super(Session, self).__init__()
        self.tempo = tempo
        self.bars = bars
        self.divs = divs
        self.inst_set = inst_set
        spb = 60. / tempo
        beats = bars * 4
        self.seconds = spb * beats
        self.clock = Clock()
        self.temp_map = SimpleTempoMap(bpm=tempo)
        self.sched = Scheduler(self.clock, self.temp_map)
        # self.players = players
        self.IM = InstrumentManager(self.sched)
        self.add(self.IM)

        ### NEW CODE ###
        self.pattern_list = PatternList(self.bars, self.tempo, self.inst_set)
        self.add(self.pattern_list)

        track = Track(num_lanes, self.bars, self.tempo)
        track.position.y = Window.height * 0.025
        controller = InstrumentKeyboard(default_keycodes, lock_in_keycode)
        self.player = Player(controller, track, inst_set)
        self.player.position.x = Window.width - player_size[0] - 20
        self.add(self.player)
        self.vplayers = []
        self.add_band_members(other_members)
        self.IM.add(self.player.instrument)

        self.clock.offset = self.seconds - spb

        self.paused = True
        self.start()
コード例 #4
0
ファイル: clock.py プロジェクト: gentimouton/crowd-control
 def __init__(self, evManager, fps):
     
     if fps == 0:
         fps = 100 #100 fps is the maximum timer resolution anyway
     Clock.__init__(self, fps)
     
     self._em = evManager
     self._em.reg_cb(QuitEvent, self.on_quit)
コード例 #5
0
    def __init__(self):
        super(MainWidget2, self).__init__()

        # create a clock and a tempo map
        self.clock = Clock()
        self.tempo_map = SimpleTempoMap(120)

        # and text to display our status
        self.label = topleft_label()
        self.add_widget(self.label)
コード例 #6
0
    def __init__(self):
        super(MainWidget3, self).__init__()

        # create a clock and TempoMap
        self.clock = Clock()
        self.tempo = SimpleTempoMap(120)

        # create a Scheduler
        self.sched = Scheduler(self.clock, self.tempo)

        # and text to display our status
        self.label = topleft_label()
        self.add_widget(self.label)

        # to see accumulated output:
        self.output_text = ''
コード例 #7
0
ファイル: clock.py プロジェクト: gentimouton/crowd-control
    def __init__(self, evManager):

        self._em = evManager
        
        fps = config_get_fps()
        if fps <= 0 or fps > 100:
            fps = 100 #100 fps is the maximum timer resolution anyway
        Clock.__init__(self, fps)
        
        # slice = set of frames between 2 logging
        self.slice_size = config_get_logperiod() * fps # number of frames in the slice
        self.slice_start_time = time.time() # the first slice starts now
        self.slice_work_time = 0 # cumulated time worked for a frame slice  
        self.cumul_ucpu_time = 0 # cumulated userland cpu time used since process started
        self.cumul_kcpu_time = 0 # cumulated kernel cpu time used since process started 
        self.cumul_vcsw = 0 # cumulated voluntary context switches, posix OS only
        self.cumul_nvcsw = 0 # cumulated involuntary switches, posix OS only
コード例 #8
0
class MainWidget4(BaseWidget):
    def __init__(self):
        super(MainWidget4, self).__init__()

        self.audio = Audio(2)
        self.synth = Synth('../data/FluidR3_GM.sf2')
        self.audio.set_generator(self.synth)

        # create clock, tempo_map, scheduler
        self.clock = Clock()
        self.tempo_map = SimpleTempoMap(120)
        self.sched = Scheduler(self.clock, self.tempo_map)

        # create the metronome:
        self.metro = Metronome(self.sched, self.synth)

        # and text to display our status
        self.label = topleft_label()
        self.add_widget(self.label)

    def on_key_down(self, keycode, modifiers):
        if keycode[1] == 'c':
            self.clock.toggle()

        if keycode[1] == 'm':
            self.metro.toggle()

        bpm_adj = lookup(keycode[1], ('up', 'down'), (10, -10))
        if bpm_adj:
            new_tempo = self.tempo_map.get_tempo() + bpm_adj
            self.tempo_map.set_tempo(new_tempo, self.sched.get_time())

    def on_update(self):
        # scheduler and audio get poked every frame
        self.sched.on_update()
        self.audio.on_update()

        bpm = self.tempo_map.get_tempo()

        self.label.text = self.sched.now_str() + '\n'
        self.label.text += 'Metronome:' + ("ON" if self.metro.playing else
                                           "OFF") + '\n'
        self.label.text += 'tempo:{}\n'.format(bpm)
        self.label.text += 'm: toggle Metronome\n'
        self.label.text += 'up/down: change speed\n'
コード例 #9
0
    def __init__(self):
        super(MainWidget4, self).__init__()

        self.audio = Audio(2)
        self.synth = Synth('../data/FluidR3_GM.sf2')
        self.audio.set_generator(self.synth)

        # create clock, tempo_map, scheduler
        self.clock = Clock()
        self.tempo_map = SimpleTempoMap(120)
        self.sched = Scheduler(self.clock, self.tempo_map)

        # create the metronome:
        self.metro = Metronome(self.sched, self.synth)

        # and text to display our status
        self.label = topleft_label()
        self.add_widget(self.label)
コード例 #10
0
class MainWidget3(BaseWidget):
    def __init__(self):
        super(MainWidget3, self).__init__()

        # create a clock and TempoMap
        self.clock = Clock()
        self.tempo = SimpleTempoMap(120)

        # create a Scheduler
        self.sched = Scheduler(self.clock, self.tempo)

        # and text to display our status
        self.label = topleft_label()
        self.add_widget(self.label)

        # to see accumulated output:
        self.output_text = ''

    def on_key_down(self, keycode, modifiers):
        if keycode[1] == 'c':
            self.clock.toggle()

        if keycode[1] == 'a':
            now = self.sched.get_tick()
            later = now + (2 * kTicksPerQuarter)
            self.output_text += "now={}. post at tick={}\n".format(now, later)
            self.cmd = self.sched.post_at_tick(self._do_it, later, 'hello')

        if keycode[1] == 'b':
            self.sched.remove(self.cmd)

    def _do_it(self, tick, msg):
        self.output_text += "{} (at {})\n".format(msg, tick)

    def on_update(self):
        # scheduler gets called every frame to process events
        self.sched.on_update()
        self.label.text = self.sched.now_str() + '\n'
        self.label.text += 'c: toggle clock\n'
        self.label.text += 'a: post event\n'
        self.label.text += 'b: remove event\n'
        self.label.text += self.output_text
コード例 #11
0
ファイル: score.py プロジェクト: yaatehr/ChordShed
 def __init__(self, callback=None):
     super(DataPlayer, self).__init__()
     self.sched = Scheduler(Clock(),
                            tempo_map=[(0, 0),
                                       (100000000000,
                                        100000000000 / 60 * 480)])
     self.beat_len = kTicksPerQuarter
     self.on_cmd = None
     self.off_cmd = None
     self.playing = False
     self.callback = None
     self.barData = None
コード例 #12
0
ファイル: main.py プロジェクト: yaatehr/ChordShed
    def __init__(self,
                 masterPattern=None,
                 key=None,
                 fileName='testoutput.txt',
                 noteDetector=None,
                 mixer=None,
                 callback=None):
        super(MainWidget, self).__init__()
        '''
        The main game instance, the pattern and keys are loaded before the screen is initialized
        ALL graphical components are controlled by the clock (update isnt' run if clock isn't playing)
         '''
        self.mixer = mixer
        self.pattern, self.patternString = masterPattern
        self.key = key

        #Audio
        self.clock = GameClock()

        self.gui = KeyboardGui(noteDetector)

        self.detector = noteDetector
        self.ticker = Ticker(self.pattern, key, self.clock)
        self.mixer.add(self.ticker.synth)
        self.player = Player(self.ticker, self.clock, masterPattern, self.key,
                             noteDetector.updateTargetChord,
                             noteDetector.getActiveNotes, callback)
        self.ticker.initialize_callbacks(self.player.increment_bar,
                                         self.player.catch_passes)
        self.detector.initializePlayer(self.player)

        crect = CRectangle(cpos=(Window.width // 2, Window.height // 2),
                           csize=(Window.width, Window.height))
        crect.texture = Image('../images/Blackboard.png').texture
        self.canvas.add(crect)

        self.canvas.add(self.player)
        self.canvas.add(self.gui)
        #midi input state
        self.info.parent = None  # make sure the label widget does not have a parent
        self.add_widget(self.info)
        self.switchScreens = callback
コード例 #13
0
class TempoCursorHandler(object):
    """
    Handles the TempoCursor GUI.
    Also stores and updates all currently active TempoCursors.
    """
    def __init__(self,
                 norm,
                 sandbox,
                 mixer,
                 client,
                 client_id,
                 block_handler,
                 tempo=60):
        self.norm = norm
        self.module_name = 'TempoCursor'
        self.sandbox = sandbox
        self.mixer = mixer
        self.client = client
        self.cid = client_id
        self.block_handler = block_handler

        self.tempo = tempo
        self.clock = Clock()
        self.tempo_map = SimpleTempoMap(bpm=self.tempo)

        self.touch_points = {}

        self.cursors = AnimGroup()
        self.sandbox.add(self.cursors)

        self.gui = CursorGUI(norm,
                             pos=self.norm.nt((20, 300)),
                             beat_callback=self.update_touch_points)

        self.delete_mode = {}

    def on_touch_down(self, cid, pos):
        if cid == self.cid:
            self.gui.on_touch_down(pos)

        if not self.sandbox.in_bounds(pos):
            return

        for cursor in self.cursors.objects:
            cursor_pos = (cursor.pos[0] - cursor.size[0] / 2,
                          cursor.pos[1] - cursor.size[1] / 2)
            if in_bounds(pos, cursor_pos, cursor.size):
                if self.delete_mode[cid]:
                    self.cursors.objects.remove(cursor)
                    self.cursors.remove(cursor)
                    return

        if self.delete_mode[cid]:
            return

        touch_points = self.touch_points[cid]

        if len(touch_points) == 0:
            return
        cursor = TempoCursor(self.norm, pos, self.tempo,
                             self.clock, self.tempo_map,
                             copy.deepcopy(touch_points), self.block_handler)
        self.cursors.add(cursor)

    def on_touch_move(self, cid, pos):
        pass

    def on_touch_up(self, cid, pos):
        pass

    def on_key_down(self, cid, key):
        if key == 'p':
            self.clock.toggle()
        if key == 'v' and cid == self.cid:
            self.delete_mode[cid] = not self.delete_mode[cid]
            self.update_server_state(post=True)
        if key == 'up':
            self.tempo += 4
            self.tempo_map.set_tempo(self.tempo)
            self.update_server_state(post=True)
        if key == 'down':
            self.tempo -= 4
            self.tempo_map.set_tempo(self.tempo)
            self.update_server_state(post=True)

    def on_update(self):
        self.cursors.on_update()

    def update_touch_points(self, touch_points):
        self.touch_points[self.cid] = touch_points
        self.update_server_state(post=True)

    def display_controls(self):
        cur_time = self.clock.get_time()
        cur_tick = self.tempo_map.time_to_tick(cur_time)
        info = 'delete mode: {}\n\n'.format(self.delete_mode[self.cid])
        info += 'tempo: {}\n'.format(self.tempo)
        return info

    def update_server_state(self, post=False):
        """Update server state. If post is True, relay this updated state to all clients."""
        state = {
            'touch_points': self.touch_points,
            'delete_mode': self.delete_mode,
            'tempo': self.tempo
        }
        data = {
            'module': self.module_name,
            'cid': self.cid,
            'state': state,
            'post': post
        }
        self.client.emit('update_state', data)

    def update_client_state(self, cid, state):
        """Update this handler's state."""
        if cid != self.cid:  # this client already updated its own state
            self.touch_points = state['touch_points']
            self.delete_mode = state['delete_mode']
            self.tempo = state['tempo']

    def sync_state(self, state):
        """
        Initial sync with the server's copy of module state.
        """
        self.touch_points = state['touch_points']
        self.delete_mode = state['delete_mode']
        self.tempo = state['tempo']

        # after initial sync, add default values for this client
        self.touch_points[self.cid] = []
        self.delete_mode[self.cid] = False

        # update server with these default values
        # post=True here because we want all other clients' states to update with this client's
        # default values.
        self.update_server_state(post=True)
コード例 #14
0
ファイル: session.py プロジェクト: jrburga/JamOn
class Session(GameObject):
    def __init__(self, other_members, tempo, bars, divs, inst_set):
        super(Session, self).__init__()
        self.tempo = tempo
        self.bars = bars
        self.divs = divs
        self.inst_set = inst_set
        spb = 60. / tempo
        beats = bars * 4
        self.seconds = spb * beats
        self.clock = Clock()
        self.temp_map = SimpleTempoMap(bpm=tempo)
        self.sched = Scheduler(self.clock, self.temp_map)
        # self.players = players
        self.IM = InstrumentManager(self.sched)
        self.add(self.IM)

        ### NEW CODE ###
        self.pattern_list = PatternList(self.bars, self.tempo, self.inst_set)
        self.add(self.pattern_list)

        track = Track(num_lanes, self.bars, self.tempo)
        track.position.y = Window.height * 0.025
        controller = InstrumentKeyboard(default_keycodes, lock_in_keycode)
        self.player = Player(controller, track, inst_set)
        self.player.position.x = Window.width - player_size[0] - 20
        self.add(self.player)
        self.vplayers = []
        self.add_band_members(other_members)
        self.IM.add(self.player.instrument)

        self.clock.offset = self.seconds - spb

        self.paused = True
        self.start()

    def add_band_members(self, other_members):
        for other_member in other_members:
            vcontroller = InstrumentController(16, other_member['id'])
            vtrack = VirtualTrack(num_lanes, self.bars, self.tempo)
            vplayer = VirtualPlayer(vcontroller, vtrack)
            self.vplayers.append(vplayer)
            self.add(vplayer)

    def on_key_down(self, event):
        # if event.keycode[1] == 'enter':on
        # 	self.toggle()
        pass

    def toggle(self):
        if self.paused:
            self.paused = False
            self.start()
        else:
            self.paused = True
            self.stop()

    def stop(self):
        self.clock.stop()

    def start(self):
        self.clock.start()

    def next_player(self, sequence):
        if self.current_player < self.num_players:
            self.players[self.current_player].note_sequence = sequence
            self.players[self.current_player].stop_composing()
            self.current_player += 1
        if self.current_player < self.num_players:
            self.players[self.current_player].start_composing()

    def on_lock_in(self, event):
        self.next_player(event.action['sequence'])

    def on_update(self):
        self.sched.on_update()
        # for player in self.players:
        now = self.clock.get_time() % self.seconds
        for vplayer in self.vplayers:
            vplayer.set_now(now)
        self.player.set_now(now)
        self.pattern_list.set_now(self.clock.get_time() % self.seconds)
コード例 #15
0
ファイル: clock.py プロジェクト: gentimouton/crowd-control
 def start(self):
     """ start the clock """
     log.debug('Clock starts to tick at ' + str(self.fps) + ' fps')
     Clock.start(self)
コード例 #16
0
ファイル: clock.py プロジェクト: gentimouton/crowd-control
 def start(self):
     self.log.debug('Clock starts to tick at ' + str(self.fps) + ' fps')
     Clock.start(self)
コード例 #17
0
ファイル: clock.py プロジェクト: gentimouton/crowd-control
 def on_quit(self, qevent):
     """ stop the while loop from running """
     Clock.stop(self)
コード例 #18
0
ファイル: main.py プロジェクト: yaatehr/ChordShed
class MainWidget(BaseWidget):
    playing = False
    info = topleft_label()

    def __init__(self,
                 masterPattern=None,
                 key=None,
                 fileName='testoutput.txt',
                 noteDetector=None,
                 mixer=None,
                 callback=None):
        super(MainWidget, self).__init__()
        '''
        The main game instance, the pattern and keys are loaded before the screen is initialized
        ALL graphical components are controlled by the clock (update isnt' run if clock isn't playing)
         '''
        self.mixer = mixer
        self.pattern, self.patternString = masterPattern
        self.key = key

        #Audio
        self.clock = GameClock()

        self.gui = KeyboardGui(noteDetector)

        self.detector = noteDetector
        self.ticker = Ticker(self.pattern, key, self.clock)
        self.mixer.add(self.ticker.synth)
        self.player = Player(self.ticker, self.clock, masterPattern, self.key,
                             noteDetector.updateTargetChord,
                             noteDetector.getActiveNotes, callback)
        self.ticker.initialize_callbacks(self.player.increment_bar,
                                         self.player.catch_passes)
        self.detector.initializePlayer(self.player)

        crect = CRectangle(cpos=(Window.width // 2, Window.height // 2),
                           csize=(Window.width, Window.height))
        crect.texture = Image('../images/Blackboard.png').texture
        self.canvas.add(crect)

        self.canvas.add(self.player)
        self.canvas.add(self.gui)
        #midi input state
        self.info.parent = None  # make sure the label widget does not have a parent
        self.add_widget(self.info)
        self.switchScreens = callback

    def on_key_down(self, keycode, modifiers):
        if keycode[1] == 'p':
            self.pause_game()

        elif keycode[1] == 'o':
            self.play_game()
        '''
        elif keycode[1] == 'c' and self.midiInput is None:
            self.initialize_controller()
            # self.playerSynth.start()

        # else:
        #     self.player.on_input(keycode[1])
        '''

    def play_game(self):
        self.clock.start()
        self.player.play_game()
        self.playing = True

    def pause_game(self):
        self.player.pause_game()
        self.clock.stop()
        self.playing = False

    def on_update(self):
        if not self.parent:
            return
        if self.playing:
            self.player.on_update()
        self.gui.on_update()
        # check for midi input and add onscreen indicator

        if not self.parent._has_midi_input():
            self.info.text = "\n\nNo Keyboard Connected"
        else:
            if self.player.scoreCard:
                self.info.text = "\n\nScore: %d" % self.player.scoreCard.getScore(
                )
            else:
                self.info.text = "\n\nPress o to Start!"

        # update personal clock
        # self.t += kivyClock.frametime
        '''