Banner
Views: 790,833,953
Time:
9 users online:  BeeKaaaay, edwinmusic, kamekku14, Ladida, Matheus2653, MiracleWater, Pink Gold Peach, Romano338, yoshii - Guests: 31 - Bots: 191 Users: 41,290 (1,502 active)
Latest: Lapideus
Tip: If you place Dragon Coins in a level, make sure there are at least 5.Not logged in.
AddmusicK 1.1.0 Beta Release (New Beta Up 5/7)
Forum Index - SMW Hacking - Resource & Tool Releases - AddmusicK 1.1.0 Beta Release (New Beta Up 5/7)
Pages: « 1 2 3 4 »
Originally posted by musicalman
Thanks for your response!

Originally posted by Codec

Nothing stops you from writing directly to the samples. Thus, it's possible to generate algorithms onto samples even if they are actively being played. For three major examples, the F-Zero engine sounds, the Super Mario All-Stars wind and the lead synth used in this song starting at 0:50 generate FM, FM and PWM, respectively. Such manipulation is quite powerful, and can be done in a variety of creative ways. Thus, it will be possible to perform both PWM and FM using software-based code on the SPC700 using AMK, as other developers have already achieved this.


Whoa, that's cool! I do remember hearing things like the above examples and thinking it was some clever sample trick, though I wasn't sure what. Admittedly I was too lazy to do any looking. Seems to me as though you plan to adopt this sort of behavior into AMK which would allow for the creation of these sounds plus other things, and it won't be painfully restricted? In any case, it would probably require a learning curve to use. It'll seem a little intimidating but I look forward to it.


Well, technically you can achieve the same effect by having two channels play the same thing, except one of them being slightly detuned and some vibrato (this is called a chorus effect IIRC), but its a bit different from a actual PWM command (from what I seen, a PWM command actually makes a sample sound more distorted, but the principle's still there). I also see that's what most people use for SMW samples to give it more flair, but I just never really saw the point in using a PWM command as much as a chorus effect to be honest. Maybe if there was a way for me to use it I would like it better, but whatever lol.
Layout by Mathos
Originally posted by Ultima
Well, technically you can achieve the same effect by having two channels play the same thing, except one of them being slightly detuned and some vibrato (this is called a chorus effect IIRC)...

It's true that you can get a chorusing effect by copying a channel and detuning the second copy, and in fact this is a useful strategy in many instances. You could even do PWM like this if you use two separate detuned saw waves, with the second being inverted and at a different phase with the first. This would take up minimal sample space however it requires two channels, and is not what you might think it is. What is being described above seems to be a method of using an algorithm to write directly to a sample in realtime, which is independent from the note sequence data. So you don't have to deal with the effect being reset every time a new note is keyed, or the effect slowing down or speeding up relative to note pitch, which would both happen if you did the effect with detuning samples. You'll see what I mean if you look at the Romancing Saga SPC referenced above. Channel1 has a killer PWM lead solo which you could never recreate so faithfully with AMK1.0x.

Originally posted by Ultima
From what I seen, a PWM command actually makes a sample sound more distorted, but the principle's still there). I also see that's what most people use for SMW samples to give it more flair, but I just never really saw the point in using a PWM command as much as a chorus effect to be honest.

I think you might? be confusing PWM and channel modulation. The latter does FM across channels afaik and that does produce a gritty distortion, which is not often associated with PWM. With that said, I suspect you could do gritty type sounds with PWM if the modulator is fast enough, (think FM synthesis). In any case, I think what is being described above is also different from channel modulation as it confines the effect to one channel, and is a lot more flexible-sounding. Like I say, I don't really understand the full scope of possibilities yet, and I may never really grasp it but it's exciting for me.

--------------------
Make more of less, that way you won't make less of more!
Originally posted by musicalman
Originally posted by Ultima
Well, technically you can achieve the same effect by having two channels play the same thing, except one of them being slightly detuned and some vibrato (this is called a chorus effect IIRC)...

It's true that you can get a chorusing effect by copying a channel and detuning the second copy, and in fact this is a useful strategy in many instances. You could even do PWM like this if you use two separate detuned saw waves, with the second being inverted and at a different phase with the first. This would take up minimal sample space however it requires two channels, and is not what you might think it is. What is being described above seems to be a method of using an algorithm to write directly to a sample in realtime, which is independent from the note sequence data. So you don't have to deal with the effect being reset every time a new note is keyed, or the effect slowing down or speeding up relative to note pitch, which would both happen if you did the effect with detuning samples. You'll see what I mean if you look at the Romancing Saga SPC referenced above. Channel1 has a killer PWM lead solo which you could never recreate so faithfully with AMK1.0x.

Originally posted by Ultima
From what I seen, a PWM command actually makes a sample sound more distorted, but the principle's still there). I also see that's what most people use for SMW samples to give it more flair, but I just never really saw the point in using a PWM command as much as a chorus effect to be honest.

I think you might? be confusing PWM and channel modulation. The latter does FM across channels afaik and that does produce a gritty distortion, which is not often associated with PWM. With that said, I suspect you could do gritty type sounds with PWM if the modulator is fast enough, (think FM synthesis). In any case, I think what is being described above is also different from channel modulation as it confines the effect to one channel, and is a lot more flexible-sounding. Like I say, I don't really understand the full scope of possibilities yet, and I may never really grasp it but it's exciting for me.


Yeah, like I said, I am not that familiar with PWM, so naturally I may be wrong on a lot of aspects. Still tho, it'll definitely be a neat addition, even with that in mind. lol
Layout by Mathos
Reminder that PWM is originally employed when an arbitrary wave modulates a pulse wave at a given sample rate to approximate analog signals with a digital one (anyone with some Arduino experience knows this), but here it refers to the timbre associated with changing the pulse width of a synthesized pulse wave. In this case the modulator wave is a low-frequency triangle wave, since the pulse width changes linearly from narrow to wide and vice versa. On the other hand, you do not apply PWM on an arbitrary carrier wave; that would become some kind of FM or phase modulation.

I have been continuing to refactor the AddmusicK code on my own repository. Some of the planned changes might be present some time in this 1.1.0 release.
YouTube · Bandcamp · Twitter · Github
Constructing Chiptune; Construing 8-Bit.
Custom theme based on Zenburn; install Lato and Liberation Mono for best results
Seconding the idea of adding the extended pitch bends to music as well, particularly being able to have each note slide to the next without redefining the pitch bend every time.
Originally posted by imamelia
Seconding the idea of adding the extended pitch bends to music as well, particularly being able to have each note slide to the next without redefining the pitch bend every time.


Tbh, I would actually want that to be extended to other commands too, like vibrato and tremolo, since those'll really benefit from the fact that you dont have to write a million of those commands if you're using multiple of those values (unless there's a way to do that already). I may be misunderstanding here, but its still something to think about I guess.

Also, anyway to make a portamento command a reality as well? There's commands for pitch bends, legato and even glissando, but not a specific one for portamentos, and IMO that kinda sucks. lol
Layout by Mathos
Originally posted by Ultima
I would actually want that to be extended to other commands too, like vibrato and tremolo, since those'll really benefit from the fact that you dont have to write a million of those commands if you're using multiple of those values (unless there's a way to do that already). I may be misunderstanding here,

I think you are. Are you asking about using vibrato/tremolo across multiple notes? If so, those commands are applied to every note until you change its value, turn it off, etc. Also thirding the idea of an easier implementation of pitch bend, and also wondering if there's a way to allow pitch bends that aren't strictly from one note to another. I've thought of dividing semitones, or just adding an offset to a pitch register maybe. I really don't know, but since the engine does seem to have linear pitch slides (you can hear as such with the vibrato command afaik), using those to do non-semitone pitch bends seems like it might work in a musical way without too much strain, though I would be the last person to know.

I did say earlier I had ideas for commands. I've finally decided to try describing my ideas. It's nothing too deal-breaking, just would make it a whole lot more awesome for my ambitions :).

I think the best way I can put it is more flexible remote codes. Not sure if they'd be called remote codes with my ideas or not, but a remote code could have instructions to modify pitch, volume, gain, pan, and anything else that would be useful. Maybe with existing commands, doesn't matter really, After each instruction, there could be an optional instruction to wait x amount of ticks until the next (useful for making multistage envelopes, perhaps). There could also be a loop command (useful for LFOs). Remote codes could continue to be called as normal, though an optional loop break argument could be included so you can decide whether a loop you specified earlier will still take effect in the next code. You could get really scary with this if you wanted, especially if it's done in a similar vane to Famitracker which allows for relative or absolute offsets of a lot of things... That's way beyond my thought process at the moment. But I'll admit, using a remote code in such a way could be awesome and extremely abusive. Even now you have to be careful with them from what I've heard so...

Also, a command to unkey a note, preserve its release and restore its settings for the next seems to be lacking. R just cuts the note, and using the q command feels stiff to me. It has uses but I don't like depending on it for all note-offs. I think having the r command cutting notes should stay, with another command that would not cut them. And of course while there are ways to manage the things I am mentioning, they're tedious to set up, and you have to sort of curve how you do things to deal with current limitations.

Here are a few examples of how I would personally want to use such a remote code system. Drawing a custom vibrato to get closer to something Tim Follin's guitar work would use (listen starting at 1:40), or get a harsher square LFO like in this Final Fantasy track. A different usage, this time for gain, could be this, watch the flute releases.

I realize I'm being picky and, maybe more than a little wishful since it's not like everyone here will be after such things, but now's as good a time as any to throw them out there.

--------------------
Make more of less, that way you won't make less of more!
Originally posted by musicalman
Originally posted by Ultima
I would actually want that to be extended to other commands too, like vibrato and tremolo, since those'll really benefit from the fact that you dont have to write a million of those commands if you're using multiple of those values (unless there's a way to do that already). I may be misunderstanding here,

I think you are. Are you asking about using vibrato/tremolo across multiple notes? If so, those commands are applied to every note until you change its value, turn it off, etc.


Wait, so you can just change the values without calling the vibrato command more than once? How would that be possible exactly?

Also, if I'm being stupid here, blame my lack of knowledge on how AMK handles for that. I'm also sorry for any inconveniences this might cause. #smw{^_^;}
Layout by Mathos
What do you mean changing values? Do you want different vibratos for each note? That's not a terribly common thing I don't think, and I don't know how you'd implement that in a simpler way directly. At present, you'll have to use find/replace commands within AMK to set up preset vibratos to make that easier.

If you just want the same vibrato on each note, you can just put in one vibrato command and the vibrato will take effect until another vibrato command.

--------------------
Make more of less, that way you won't make less of more!
Originally posted by musicalman
What do you mean changing values? Do you want different vibratos for each note? That's not a terribly common thing I don't think, and I don't know how you'd implement that in a simpler way directly. At present, you'll have to use find/replace commands within AMK to set up preset vibratos to make that easier.

If you just want the same vibrato on each note, you can just put in one vibrato command and the vibrato will take effect until another vibrato command.


Yeah, pretty much, since one port I have been converting into MML actually uses different values for the vibrato at one part of the song. I'm not sure if you have saw my PM tho, but if you did, its basically the part with the overdriven guitar, where it has a fast vibrato with less depth first, then it switches with one that has a higher depth each time the notes are held in that part. Here's the port btw:

https://dl.dropbox.com/s/pq1mdo78t0heg1l/Gundam%20Wing%20Endless%20Duel%20-%20Arctic%20%28Tallgeese%29%20%28SNES%20Arrange%29.spc?dl=0 (it might be starting at 0:18, not sure)

And here's the MML:

https://www.dropbox.com/s/rp2i263le8ct6px/Tallgeese.txt?dl=0

With the process in creating the SPC, I just pasted the vibrato commands wherever I saw fit, but in AMK, it seems to be a bit different. Not really sure if pasting the commands over and over takes out space, but if it does, then yeah, a command like that's definitely necessary. lol
Layout by Mathos
You can apply certain commands in the middle of a note by using a ^ command. The manual does not mention that this can be used without preceding it with a note. For example, this in FamiTracker
Code
     # : Triangle
ROW 00 : C-4 00 . 4XY
ROW 01 : ... .. . ...
ROW 02 : ... .. . 4XZ
ROW 03 : ... .. . ...
ROW 04 : ... .. . ...
ROW 05 : ... .. . ...

roughly becomes
Code
o4 pX,Y c8 pX,Z ^4

This is often sufficient for most purposes where this occurs. Many MML dialects and their sound engines have similar support for a tie command to various degrees. That said, vibrato has a plaintext representation, so you should always prefer them over hex commands, and if AddmusicK incorporates more plaintext commands, you should prefer those as well.

Doing this for all notes uniformly requires something like this:
Code
(!1)[pX,Y]
(!2)[pX,Z]

(!1,-1) (!2,1,8) o4 c4.

But this does not scale well if multiple changes are needed. So to solve this I managed to add a new remote code type myself, that triggers exactly once after the specified number of ticks, so that if remote code can be reconfigured inside other remote code definitions, then this will produce a crude "square" vibrato: (this requires MML compiler support, so I had to expand them into hex commands and disable validation)
Code
(!1)[$EE$00 (!2,6,=9)]		; these are equivalent to { 32 ... | 64 ... 0 ... }
(!2)[$EE$40 (!1,6,=9)]		; type 6 remote code behaves like most other types
(!3)[$EE$20 (!2,6,=24)]		; so it will overwrite existing type 0/1/2/3 codes

#0	p0,1			; required to update pitch on all ticks
	(!3,-1)			; envelope init
	c2d2e1

Where type 6 is defined as:
Code
L_10A1:

	mov	a, !remoteCodeType+x
	cmp	a, #$06					;;; ;; ; type 6 also uses the time counter
	beq	+					;;; ;; ; branch
	cmp	a, #$01
	bne	.noRemoteCode2
+	mov	a, !remoteCodeTimeLeft+x
	beq	.noRemoteCode2				;;; ;; ; prevent type 6 code from triggering more than once
	dec	a					; $FC$xx$yy$01 $00 will also not work but the impact is minimal
	mov	!remoteCodeTimeLeft+x, a
	bne	.noRemoteCode2
	call	RunRemoteCode

Code
cmdFC:
{
	; ...
	mov	!remoteCodeType+x, a			; |
	cmp	a, #$06					;;; ;; ; special handling for type 6 remote code
	beq	.callOnce				;;; ;; ; branch
	call	GetCommandDataFast			; \ Store the argument.
	mov	!remoteCodeTimeValue+x, a		; /
	ret						;
	
.callOnce						;;; ;; ;
	call	GetCommandDataFast			;;; ;; ; this does not update the timer reload value
	mov	!remoteCodeTimeLeft+x, a		;;; ;; ; instead it updates the timer current value
	ret						;;; ;; ;

This is the resulting SPC. The entire assembly code requires 17 extra bytes. The next logical step is to add a "yield" command inside remote code definitions to simplify the process of creating multi-step envelopes; in fact, such a yield command might obviate the need for another remote code type if done properly. There is always the question of whether the gained expressive power outweighs the increases code size, but if arpeggio and pulse wave pass, then so shall this.

Speaking of remote code, type 5 seems to behave exactly like type 3. It appears in the code that handles conversion from #amk=1 GAIN commands to remote code definitions. Does anyone close to AddmusicK development know why it was added in the first place?
YouTube · Bandcamp · Twitter · Github
Constructing Chiptune; Construing 8-Bit.
Custom theme based on Zenburn; install Lato and Liberation Mono for best results
Originally posted by HertzDevil
Originally posted by AntiDuck
The effect used in the Ocean games have much more flexibility in use, such as going below $00 and going backwards through $FF to $80 in the reverb values and so forth, and slowing down when reaching the desired value...

I looked into the Waterworld SPC files. There is a low frequency sine oscillator built into the sound engine, that writes to the echo volume registers independently from the channel events. It appears that the LFO's frequency and phase offset are fixed, and the only controls possible are changing its amplitude. Sometimes the echo volume in Diving overflows / underflows, because the LFO operates by adding the amplified differential to a cached value, not amplifying this cached value. Regardless of the underlying implementation I do not believe that such a feature would be sufficiently useful for the general AMK user.

Originally posted by AntiDuck
...I tested out SPC2MML with one of the ports to see if it used any hex command that could be strategically using echo commands with available AMK commands, but they don't seem to, so that must mean that there is a special command that the Ocean games used.

An Ocean SPC does not use N-SPC / AMK commands and, before anyone asks, there are no such things as "SPC commands" either, not any less general than DSP writes. SPC2MML only attempts its best to collect as many DSP writes into events understood by AMK as possible, but since different sound engines have vastly different semantics (observable behaviour), detection of high-level features requiring continuous register writes is virtually impossible. In particular SPC2MML cannot detect AMK's own $F2 command. So there are only very limited conclusions you can draw from these converted MML files.


I thought of something, since I can understand that not many would want to use the command for their ports, how about some sort of distribution of various commands from other SNES games that aren't necessarily part of AMK, but can be inserted in the program itself like custom music or something, and perhaps they can be used in a command format like
Code
"#Custom_Command1 $XX $YY" or "#Custom_Command2 $ZZ"
or something to co-exist with other commands and not risk overwriting them or something.
Maybe this could be used for ports that require a certain command or effect to be more accurate but don't have much use for any other port or something.

I may seem to be wishing too much, but I'm just wondering if any of this could be possible, guess I'm just that interested in the LFO effect. Maybe it could be altered to also work on other values like song volume, pitch, ADSR/Gain or something to make it a little more useful?

---

But I also have another suggestion, can AMK also have support for MSU-1 use, like this one patch uses in this thread? If you can't use the first option, then maybe at least consider the latter?

--------------------
"LOOK A_ ME IM SMR_"
I have recently got per-channel o / l states working in my own mod. Let's see if Codec will merge that, because it is one of the most requested fixes outside SMWCentral.



More about remote code commands: I discovered another trick that would work readily in the current AMK sound engine, but only if nested remote code setups are allowed:
Code
(!1)[v240 (!2,-1)]
(!2)[v240 (!3,-1)]
(!3)[v150 (!2,-1)]

#0	@9 $FA$03$FF l16
	(4)[(!1,-1)  c8 e c ge>c<g >ec<g>ec<g>ec<]2
	   [(!1,-1)  c8 d c ad>d<a >fd<a>fd<a>fd<]2
	   [(!1,-1) <b8>d<b>gd>d<g >fd<g>fd<g>fd<]2
	(4)2

This creates an envelope similar to the type 6 remote code from above, except it is only updated every time a note is triggered. It performs the following actions in sequences:
  1. (!1,-1) is issued, initializing the channel volume to 240.
  2. The next note, an 8th note, plays at the volume.
  3. The remote code calls (!2,-1) for the next note.
  4. The next note, a 16th note, also plays at the normal volume (v240).
  5. The remote code now calls (!3,-1) for the next note (the q command currently requires first setting the note length, so it cannot be used inside remote code definitions without further modification to the source).
  6. The next note is now played at a lower volume (v150).
  7. The remote code calls (!2,-1) again, going back to step 4.
This effectively produces a single-channel echo effect that is commonly used for many types of chiptune music, and if pulse wave synthesis is back, I am sure some porters will do this as well. The first (!1) is unnecessary, but saves the effort of making the first note play at full duration. Here is the resulting SPC file, compiled using AddmusicK 1.0.5. Again, the remote commands are manually adjusted to point to the correct definitions using a hex editor.

The first loop of the example is equivalent to v240c8 ev150c v240gv150e> v240c<v150g> v240ev150c< v240g>v150e v240c<v150g> v240ev150c<, but this is way more error-prone, and increases the size of the entire music data by 45 bytes even for such a small example. Some other MML dialects, e.g. PPMCK and PMD, also provide a similar macro which expands notes into individual commands during compile-time, but since AddmusicK's N-SPC engine already expresses this, I'd say that AddmusicK add support for those "nested" remote code commands (this is what I will do since it makes things more flexible), including recursive ones that refer to each other, or at least add a macro that generates such remote code sets and possibly the echoing notes.



Originally posted by AntiDuck
I thought of something, since I can understand that not many would want to use the command for their ports, how about some sort of distribution of various commands from other SNES games that aren't necessarily part of AMK, but can be inserted in the program itself like custom music or something, and perhaps they can be used in a command format like
Code
"#Custom_Command1 $XX $YY" or "#Custom_Command2 $ZZ"
or something to co-exist with other commands and not risk overwriting them or something.
Maybe this could be used for ports that require a certain command or effect to be more accurate but don't have much use for any other port or something.

I may seem to be wishing too much, but I'm just wondering if any of this could be possible, guess I'm just that interested in the LFO effect. Maybe it could be altered to also work on other values like song volume, pitch, ADSR/Gain or something to make it a little more useful?

The easiest way to do this, arguably, is to add a command line option that passes defines to ASAR (possibly creating an extra temporary file to be incsrc'd by the other sources). Whoever adds extra features in their own copy of the SPC700 source is responsible for conditionally enabling relevant code with these defines.

And no, you really cannot easily isolate any effect from another sound engine and force it into N-SPC.
YouTube · Bandcamp · Twitter · Github
Constructing Chiptune; Construing 8-Bit.
Custom theme based on Zenburn; install Lato and Liberation Mono for best results
Can something about the annoying crackles (example here) be done?
This happens anytime you combine an ADSR with instant attack and gain.
In the example:
(!800)[$ed$7f$e5]
(!801)[$ed$80$20]
(!800,-1)
(!801,3)

Would be cool, since this is a frequent setting I adopt, but can't use due to the crackles you hear randomly.
a while ago i began working on getting sample streaming into amk but got lazy and stopped (not much progress, mainly small tests and an outline), so maybe youre willing to do it?


i basically planned to use the routine i developed for my bad apple demo (src), so something like:

1. a "call streamer" in AMK's main.asm MainLoop. streamer would contain checks and stuff to see if streaming should occur, and also the actual streaming code (slightly modified from the one i made)

2. uncomment the "write to ARAM" command in Commands.asm

3. have a large null sample, in order to reserve space in ARAM (around xF00 bytes, maybe less)

4. some snes-side nmi code that checks the spc ports

5. a list that goes alongside the nmi code. the list would contain pointers to the sample data in ROM plus each sample's length (since the SPC would otherwise have no way of knowing when to stop streaming a sample). im thinking hardcoding it to 255 samples total would be easiest

6. in the song that'll use sample streaming, set up the null sample under #samples and #instruments like any other sample (though under #instruments give it the properties $8F $E0 $00 $03 $D4)

7. at the beginning of the song put something like $F9 $00 $69 to tell the snes-side nmi code that the song would like to stream samples (and so the snes sets up hdma)

8. one of the channels in the song will be reserved for sample streaming. that channel should contain something like @xx o4c1[r1]128/ and nothing else (@xx being the null brr instrument)

9. when you want to stream a sample, in one of the other channels (not the sample-streaming channel; that one should remain empty except for the code above), play $F7 $yy $00 $F8 (yy being one of the streamable samples in the list, but not 00 since 00 would be reserved for no streaming or something)


basically, the SPC determines whether streaming should occur (obviously not every song will stream samples), what sample should stream, and when it should begin streaming said sample during song playback, and the SNES just determines when sample streaming should end


this method obviously brings limitations, a couple would be that one (and only one) of the channels would be reserved for streaming and thus unusable. also, one of the HDMA channels would be reserved for streaming (and thus unusable). also, if a song takes up a large amount of SPC time normally, it may affect sample streaming negatively. also, a sample cant be too long since the buffer (the space that the null sample reserves) isnt too long. if a sample is too long, it'll clip/glitch. "too long" means more than 30 or so seconds


yay? nay?
My schedule has been preventing me recently from doing a lot of work on this, so I'm probably not going to attempt implementation until after I create a release candidate for 1.1.0, as my main goal of AMK 1.1.0 was to make it so that none of the 5A22-side code needed to be changed. I'm hoping to release something soon so that people can try out the PWM/FM implementation. I may look into the capacity of making the streaming user-friendly for a future release, but for now, it's not in the cards for it yet.



Originally posted by Wakana
Can something about the annoying crackles (example here) be done?
This happens anytime you combine an ADSR with instant attack and gain.
In the example:
(!800)[$ed$7f$e5]
(!801)[$ed$80$20]
(!800,-1)
(!801,3)

Would be cool, since this is a frequent setting I adopt, but can't use due to the crackles you hear randomly.


I can try to see what I can do, but I suspect that hardware limitations might be the cause as you said in a PM that this occurred with AddmusicK 1.05.
Originally posted by Wakana
Can something about the annoying crackles (example here) be done?
This happens anytime you combine an ADSR with instant attack and gain.
In the example:
(!800)[$ed$7f$e5]
(!801)[$ed$80$20]
(!800,-1)
(!801,3)

Would be cool, since this is a frequent setting I adopt, but can't use due to the crackles you hear randomly.

It is already possible to do this without causing crackles, but you have to manually set the GAIN to decrease and set it back to keep it in place manually.
Basically use a GAIN value of 81-9F or A1-BF and then use the "stopping" value of those that keeps the GAIN at the same level, 80 or A0.

Code
(!100)[$ED $80 $7F]
(!101)[$ED $80 $B8]

#0
(!100,-1)
(!101,3)
c16r=01$ED $80 $A0r=11 d16r=01$ED $80 $A0r=11 e16r=01$ED $80 $A0r=11		;\different ways of writing the same thing
c16r192$ED $80 $A0r32.^96 d16r192$ED $80 $A0r32.^96 e16r192$ED $80 $A0r32.^96	;/
c16r64$ED $80 $A0r32. d16r64$ED $80 $A0r32. e16r64$ED $80 $A0r32.		;change either the length of rests or the speed of the GAIN to change the note off volume


example SPC:
https://dl.dropbox.com/s/4de0grvax0mw0rg/bach.spc
https://dl.dropbox.com/s/vk8oc5fmrpjnovm/bach.txt

mod edit: less table stretch please

--------------------
Originally posted by Ladida
sample streaming stuff

Seems like a good idea to me. I recall that p4plus2 was going to do something like that for a future Addmusic release but had to can it because it wouldn't work on ZSNES. Though why do you need an empty channel to stream the samples? And how would this work with sound effects (which are the main thing I'd want to use sample streaming for)?
I think Ladida is talking about streaming samples while a song is playing?

--------------------
Yes, but that still doesn't explain the need for an empty channel.
Pages: « 1 2 3 4 »
Forum Index - SMW Hacking - Resource & Tool Releases - AddmusicK 1.1.0 Beta Release (New Beta Up 5/7)

The purpose of this site is not to distribute copyrighted material, but to honor one of our favourite games.

Copyright © 2005 - 2019 - SMW Central
Legal Information - Privacy Policy - Link To Us


Total queries: 7

Menu

Follow Us On

  • YouTube
  • Twitch
  • Twitter

Affiliates

  • SMBX Community
  • ROMhacking.net
  • MFGG