Soitan rumpuja ja tabulatuurien lukeminen on ainakin minulle sangen hidasta. Onkohan olemassa jotain helppoa kirjastoa valmiina, jolla saisi helposti tehtyä guitar hero tyylisen ylhäältä alaspäin liikkuvan "janan", jossa lyöntikohdat näkyvät? Näin olisi vähän helpompi opetella tuntemattomia kappaleita ensimmäisiä kertoja. Tabulatuurit ovat muotoa:
C |X---------------|----------------|----------------|------------X---| H |----X---X---X---|X---X---X---X---|X---X---X---X---|X---X---X-------| S |----o-------o---|----o-------o---|----o-------o---|----o-------o---| B |o---------o---o-|--o---o---o-----|o-o---o---o---o-|--o-------o-----| B2|----------------|----------------|----------------|-----------o----|
Noita rivejä on niin monta kuin eri symbaaleita, tomeja, bassoa tai hi-hattia tarvitsee lyödä, joten mitä enemmän lyötäviä juttuja, niin sitä enemmän rivejä: rivit siis eivät ole aina samassa järjestyksessä.
Täällä vielä yhdet tabulatuurit malliksi kokonaan.
Osaisin itse tehdä tuon tabulatuurin pilkkomisen koneelle järkevään muotoon, mutta itseltäni puuttuu taidot näyttää tuo data 2d/3d -grafiikkana. Vinkkejä?
Tämä ei liity kysymykseesi, mutta oletko harkinnut Guitar Pro -ohjelman hankkimista? Tai OS-versiota, Tuxguitaria? Niissä rummut on merkitty nuottiviivastolle sekä tabulatuureina. Voit myös säätää ohjelman tempoa harjoittelumoodiin tai alkuperäiseen rytmiin.
Java sopisi, koska siinä on helppo 2d grafiikka kirjasto.
Itse koodaisin tuon nettisivuna. Homman voisi joko toteuttaa kokonaan JavaScriptilla (vaikka jQuery-kirjastolla) tai luomalla jollain muulla nettisivun, jossa kaikki nuolet sijaitsevat valmiiksi, ja toteuttamalla JS:llä vain automaattisen skrollauksen. Jälkimmäisestä tulisi pitkillä tabulatuureilla raskas, kun taas ensimmäisessä rajoittava tekijä olisi kerralla näkyvillä olevien elementtien määrä.
Metabolix kirjoitti:
Itse koodaisin tuon nettisivuna.
No sinä nyt olet nettiguru :D
Millaisella nopeudella tuon pitäisi scrollata?
Infernollakin tuo onnistuisi varmaan kohtuu kivasti.
jalski kirjoitti:
Millaisella nopeudella tuon pitäisi scrollata?
Infernollakin tuo onnistuisi varmaan kohtuu kivasti.
Nopeus, tai oikeastaan tempo, onkin ohjelman suurin ongelma. Tabulatuuria käsitellessä nimittäin pitäisi tietää kappaleen tempo, ja sen selvittäminen saattaa olla hankalaa. Esimerkissä on tabulatuurit Master of Puppetsiin ja se on n. 220 bpm.
Tosin ohjelmaan voisi helposti koodata säätimen, jolla voi hakea oikean temmon...
Jokotai kirjoitti:
Metabolix kirjoitti:
Itse koodaisin tuon nettisivuna.
No sinä nyt olet nettiguru :D
Ei toiselle pidä suositella sopivaa välinettä sen mukaan, mitä itse osaa, vaan sen mukaan, mikä on ongelman kannalta käytännöllinen. Uskon, että tabulatuuri toimisi nettisivuna tarpeeksi sulavasti, ja koodia varmasti tulisi paljon vähemmän kuin tuolla ehdottamallasi Javalla, jota kyllä myös osaan. (Oletko muuten itse koskaan tehnyt Javalla kunnollista käyttöliittymää? Sen grafiikkatoiminnot eivät todellakaan ole yksinkertaisimmasta päästä.)
Tarvisiko tuo muuta, kuin parserin minkä avulla tabulatuurit luetaan tekstitiedostosta, käyttöliittymäksi slideri, millä voi muuttaa tempoa ja ylhäältä alaspäin scrollaava tabulatuurien graafinen esitys?
jalski kirjoitti:
Tarvisiko tuo muuta, kuin parserin minkä avulla tabulatuurit luetaan tekstitiedostosta, käyttöliittymäksi slideri, millä voi muuttaa tempoa ja ylhäältä alaspäin scrollaava tabulatuurien graafinen esitys?
Ei. Ainoa ongelma itselleni on tuo viimeisein, eli ylhäältä alspäin scrollaava graafinen esitys.
punppis kirjoitti:
Ei. Ainoa ongelma itselleni on tuo viimeisein, eli ylhäältä alspäin scrollaava graafinen esitys.
En tiedä, millä ohjelmointityökaluilla tykkäät touhuta, mutta Infernolla tekisin yksinkertaisesti varmaan jotakin alla olevan kaltaista:
1. Piirtäisin koko tabulaari-esityksen yhteen isoon imageen.
2. Piirtäisin tästä imagesta näytölle mahtuvan kokoisen rectanglen alueen näkyville.
3. liikuttamalla edellisessä vaiheessa mainitun rectanglen lähdekoordinaatteja ja piirtämällä tämän sisältö saadaan esitys scrollaamaan.
punppis kirjoitti:
Näin olisi vähän helpompi opetella tuntemattomia kappaleita ensimmäisiä kertoja.
Muusikon vinkki: soita ensin hitaasti, ja ala nopeuttaa vasta, kun onnistuu hitaampana. Jos ei opi soittamaan hitaasti, ei opi soittamaan nopeasti. Samalla nuotinlukutaito karttuu. Kärsivällisyyttä.
Kieli poskessa tein kuitenkin HTML-Rumpusankarin.
Gwaur kirjoitti:
Muusikon vinkki: soita ensin hitaasti, ja ala nopeuttaa vasta, kun onnistuu hitaampana.
Lähinnä sitä varten haluaisin tuollaisen systeemin, että muistaisin mitä piti soittaa seuraavaksi. Rumpalit ei yleensäkään kyllä lue nuotteja.
punppis kirjoitti:
Rumpalit ei yleensäkään kyllä lue nuotteja.
Siksi ihmettelenkin, miksi edes haluat soittaa tabulatuurista. Etukäteen kirjoitetun kompin soittamisesta tulee väkisinkin hieman jäykkä tunnelma. Ota mieluummin jokin tuttu biisi (tai tutustu johonkin) ja soita omasta päästä suunnilleen alkuperäisen tyylin mukaan. Vaikka missaisit osan filleistä ja aksenteista, luultavasti lopputulos on parempi, kun et hätäile liikaa. :)
Rumpuja soittaessa kannattaa pitää mielessä, että tekniikka ja rytmitaju eivät tule vain setin ääressä. Muista harjoitella välillä erilaisia rytmikuvioita metronomin kanssa eri nopeuksilla (tarpeeksi hitaasti!) niin, että rytmit ovat aivan täsmällisiä. Nauhoita, kuuntele ja korjaa. Tekniikkaharjoitukset ovat ehkä tylsiä, mutta hyväksi rumpaliksi ei pääse ilman: satunnaiselle kuuntelijalle jää jopa pienestä epätarkkuudesta usein tunne, että soitto ei jostain syystä aivan istunut, ja harjaantunut korva kuulee monin verroin enemmän virheitä. Valitettavan harva settirumpali ymmärtää ja uskoo tämän, kun vieläpä omasta ja kavereiden mielestä saundi on joka tapauksessa aivan mahtava. :/
Metabolix kirjoitti:
Etukäteen kirjoitetun kompin soittamisesta tulee väkisinkin hieman jäykkä tunnelma.
Tässä vihjaat, että etukäteen kirjoitettua komppia ei saa kuulostamaan hyvältä.
Metabolix kirjoitti:
Muista harjoitella välillä erilaisia rytmikuvioita metronomin kanssa eri nopeuksilla (tarpeeksi hitaasti!) niin, että rytmit ovat aivan täsmällisiä. Nauhoita, kuuntele ja korjaa.
Tässä taas vihjaat, että täsmälliseen toisintamiseen tulee pyrkiä. Jos ajoittaisten fillien ja aksenttien missaamisen voi hyväksyä, nuoteista ja äänitteestä harjoitteleminen eivät pahemmin eroa toisistaan, koska tällöin nuotistakin voi poiketa saman verran.
Onhan valtavan suuri osa kaikesta tehdystä musiikista etukäteen tarkalleen kirjoitettua, mutta hyvin esitettynä ei kuulosta suinkaan jäykältä (ellei sävellys sitä vaadi). ;)
Gwaur kirjoitti:
Tässä vihjaat, että etukäteen kirjoitettua komppia ei saa kuulostamaan hyvältä. – – Tässä taas vihjaat, että täsmälliseen toisintamiseen tulee pyrkiä.
Täsmällisyys on eri asia kuin yksitoikkoisuus. Komppiin tuodaan elävyyttä dynamiikoilla ja hallitulla muuntelulla, ei suinkaan virheillä ja epätarkkuudella. Tabulatuuriin tällaista muuntelua ei yleensä jakseta kirjoittaa, koska sen täsmällinen toistaminen ei ole olennaista tai edes suotavaa. Lisäksi tarkka lukeminen häiritsee soittamista, jolloin virheitä tulee entistä enemmän.
Verrataanpa soittamista esseen kirjoittamiseen: Tekstin elävyyttä lisätään sanavalinnoilla ja sävyillä, ei suinkaan tekemällä kielioppivirheitä. Sen sijaan kieliopin hallitseminen sekä parantaa suoraan lopputulosta että helpottaa elävän tekstin kirjoittamista.
Gwaur kirjoitti:
Jos ajoittaisten fillien ja aksenttien missaamisen voi hyväksyä, nuoteista ja äänitteestä harjoitteleminen eivät pahemmin eroa toisistaan, koska tällöin nuotistakin voi poiketa saman verran.
Toki, mutta tällöin ei minusta olisi tarkoituksenmukaista kehitellä ohjelmaa, joka pyörittää täsmällisesti koko komppia ruudulla. Ennemmin pitäisi tehdä ohjelma, joka näyttää vain fillit ja aksentit; peruskompin voisi sitten improvisoida. :) Itse asiassa setille usein kirjoitetaankin vain yksi tahti kutakin komppia ja myöhemmin ainoastaan erityiset kohdat.
Gwaur kirjoitti:
Onhan valtavan suuri osa kaikesta tehdystä musiikista etukäteen tarkalleen kirjoitettua, mutta hyvin esitettynä ei kuulosta suinkaan jäykältä (ellei sävellys sitä vaadi). ;)
Kevyttä musiikkia harvoin kirjoitetaan yhtä yksityiskohtaisesti kuin klassista, ja silti myös klassisessa musiikissa käytetään säveltäjän tarkkojen ohjeiden lisäksi runsaasti dynamiikkoja ja sävyjä, joita ei ole lainkaan paperilla.
Ohessa Limbo esimerkki Infernolle ylä-alasuunnassa scrollauksesta.
Sovellat vain tuota hiukan, toteutat parserin tabulaarien lukemista varten tekstitiedostosta ja teet rutiinin, mikä piirtää parsitun tiedon pohjalta tabulaarien graafisen esityksen imageen. Parserin -ja piirtorutiinin rungot voit lainata toiseen aiheeseen linkittämästäni pelistä.
Pizza menu scroller:
implement PizzaScroller;
include "sys.m";
sys: Sys;
include "draw.m";
draw: Draw;
Context, Display, Point, Rect, Image, Screen: import draw;
include "tk.m";
tk: Tk;
Toplevel: import tk;
include "tkclient.m";
tkclient: Tkclient;
PizzaScroller: module
{
init: fn(ctxt: ref Context, argv: list of string);
};
display : ref Display;
t: ref Toplevel;
Tick: adt {
delay: int;
new : fn(delay : int) : ref Tick;
set : fn(t : self ref Tick, delay : int);
};
tickch : chan of int;
tick : ref Tick;
pizzamenu_cfg := array[] of {
"frame .f",
"frame .b",
"scale .b.delay -label {Scroll delay} -from 100 -to 1000 -orient horizontal" +
" -showvalue 0 -command {send cmd delay}",
".b.delay set 500",
"pack .b.delay -side left -fill x -expand 1",
"pack .b -side top -fill both -expand 1",
"pack .f -side bottom -fill both -expand 1"
};
init(ctxt: ref Context, nil: list of string)
{
sys = load Sys Sys->PATH;
draw = load Draw Draw->PATH;
tk = load Tk Tk->PATH;
tkclient = load Tkclient Tkclient->PATH;
sys->pctl(Sys->NEWPGRP, nil);
tkclient->init();
if(ctxt == nil)
ctxt = tkclient->makedrawcontext();
display = ctxt.display;
menubut: chan of string;
(t, menubut) = tkclient->toplevel(ctxt, "", "Pizza menu scroller", 0);
cmdch := chan of string;
tk->namechan(t, cmdch, "cmd");
for (i := 0; i < len pizzamenu_cfg; i++)
cmd(t, pizzamenu_cfg[i]);
cmd(t, "update");
tkclient->startinput(t, "ptr"::"kbd"::nil);
tkclient->onscreen(t, nil);
tickch = chan of int;
tick = Tick.new(500);
spawn scroller();
for(;;) alt {
s := <- t.ctxt.kbd =>
tk->keyboard(t, s);
s := <- t.ctxt.ptr =>
tk->pointer(t, *s);
s := <- t.ctxt.ctl or
s = <- t.wreq or
s = <- menubut =>
tkclient->wmctl(t, s);
cmd := <- cmdch =>
(nil, tokens) := sys->tokenize(cmd, " ");
if(hd tokens == "delay")
{
tick.set(int hd tl tokens);
}
}
}
scroller()
{
xy := Point(0, 0);
dy := 4;
pizzamenu := display.open("/icons/pizzamenu.bit");
ymax := pizzamenu.r.dy() / 4;
bufr := Rect(Point(0,0), Point(pizzamenu.r.dx(), ymax));
ymax *= 3;
buffer := display.newimage(bufr, t.image.chans, 0, Draw->Black);
if (buffer == nil) {
sys->fprint(sys->fildes(2), "Pizza menu scroller: failed to allocate image\n");
exit;
}
buffer.draw(bufr, pizzamenu, nil, xy );
cmd(t, "panel .f.p -bd 3 -relief flat");
cmd(t, "pack .f.p -fill both -expand 1");
tk->putimage(t, ".f.p", buffer, nil);
cmd(t, ".f.p dirty; update");
spawn ticker(tickch, tick);
xy.y += dy;
while(1)
{
if (xy.y <= 0 || xy.y >= ymax )
dy = - dy;
<- tickch;
buffer.draw(bufr, pizzamenu, nil, xy );
cmd(t, ".f.p dirty; update");
xy.y += dy;
}
}
Tick.new(delay : int) : ref Tick
{
t := ref Tick (delay);
return t;
}
Tick.set(t : self ref Tick, delay : int)
{
t.delay = delay;
}
ticker(tick: chan of int, ticki: ref Tick)
{
tick <-= 1;
while((delay := ticki.delay) >= 0) {
sys->sleep(delay);
tick <-= 1;
}
tick <-= 0;
}
cmd(win: ref Tk->Toplevel, s: string): string
{
r := tk->cmd(win, s);
if (len r > 0 && r[0] == '!') {
sys->print("error executing '%s': %s\n", s, r[1:]);
}
return r;
}Aihe on jo aika vanha, joten et voi enää vastata siihen.