From 7b6482872ec06317028bacf6cb694a479b942d56 Mon Sep 17 00:00:00 2001 From: Hans-Christoph Steiner Date: Fri, 22 Aug 2003 00:20:54 +0000 Subject: added 0.37 version from pddp_referencesfiles.zip svn path=/trunk/; revision=890 --- doc/pddp/all_about_arrays.pd | 677 ++++++++++++++++++++++++++++++++++++++++++ doc/pddp/help-acoustics.pd | 583 ++++++++++++++++++++++++++++++++++++ doc/pddp/help-adc~.pd | 68 +++++ doc/pddp/help-adc~_dac~.pd | 108 +++++++ doc/pddp/help-bang.pd | 143 +++++++++ doc/pddp/help-bendin.pd | 66 ++++ doc/pddp/help-bendout.pd | 67 +++++ doc/pddp/help-bng.pd | 269 +++++++++++++++++ doc/pddp/help-change.pd | 52 ++++ doc/pddp/help-clip.pd | 130 ++++++++ doc/pddp/help-cputime.pd | 112 +++++++ doc/pddp/help-ctlin.pd | 86 ++++++ doc/pddp/help-ctlout.pd | 90 ++++++ doc/pddp/help-dac~.pd | 68 +++++ doc/pddp/help-delay.pd | 139 +++++++++ doc/pddp/help-float.pd | 88 ++++++ doc/pddp/help-int.pd | 83 ++++++ doc/pddp/help-line.pd | 166 +++++++++++ doc/pddp/help-loadbang.pd | 97 ++++++ doc/pddp/help-makefilename.pd | 244 +++++++++++++++ doc/pddp/help-math.pd | 162 ++++++++++ doc/pddp/help-metro.pd | 50 ++++ doc/pddp/help-midi.pd | 121 ++++++++ doc/pddp/help-moses.pd | 57 ++++ doc/pddp/help-notein.pd | 85 ++++++ doc/pddp/help-noteout.pd | 91 ++++++ doc/pddp/help-operators.pd | 283 ++++++++++++++++++ doc/pddp/help-otherbinops.pd | 435 +++++++++++++++++++++++++++ doc/pddp/help-pack.pd | 128 ++++++++ doc/pddp/help-pgmin.pd | 67 +++++ doc/pddp/help-pgmout.pd | 68 +++++ doc/pddp/help-pipe.pd | 117 ++++++++ doc/pddp/help-print.pd | 50 ++++ doc/pddp/help-random.pd | 182 ++++++++++++ doc/pddp/help-realtime.pd | 108 +++++++ doc/pddp/help-receive.pd | 11 + doc/pddp/help-route.pd | 139 +++++++++ doc/pddp/help-select.pd | 212 +++++++++++++ doc/pddp/help-send.pd | 199 +++++++++++++ doc/pddp/help-spigot.pd | 119 ++++++++ doc/pddp/help-swap.pd | 185 ++++++++++++ doc/pddp/help-symbol.pd | 67 +++++ doc/pddp/help-tabread.pd | 93 ++++++ doc/pddp/help-tabread4.pd | 148 +++++++++ doc/pddp/help-tabwrite.pd | 98 ++++++ doc/pddp/help-timer.pd | 108 +++++++ doc/pddp/help-trigger.pd | 225 ++++++++++++++ doc/pddp/help-unpack.pd | 49 +++ doc/pddp/help-until.pd | 89 ++++++ doc/pddp/help-value.pd | 102 +++++++ doc/pddp/midi-basics.pd | 45 +++ doc/pddp/pddp.pd | 31 ++ doc/pddp/time_measurements.pd | 65 ++++ 53 files changed, 7325 insertions(+) create mode 100644 doc/pddp/all_about_arrays.pd create mode 100644 doc/pddp/help-acoustics.pd create mode 100644 doc/pddp/help-adc~.pd create mode 100644 doc/pddp/help-adc~_dac~.pd create mode 100644 doc/pddp/help-bang.pd create mode 100644 doc/pddp/help-bendin.pd create mode 100644 doc/pddp/help-bendout.pd create mode 100644 doc/pddp/help-bng.pd create mode 100644 doc/pddp/help-change.pd create mode 100644 doc/pddp/help-clip.pd create mode 100644 doc/pddp/help-cputime.pd create mode 100644 doc/pddp/help-ctlin.pd create mode 100644 doc/pddp/help-ctlout.pd create mode 100644 doc/pddp/help-dac~.pd create mode 100644 doc/pddp/help-delay.pd create mode 100644 doc/pddp/help-float.pd create mode 100644 doc/pddp/help-int.pd create mode 100644 doc/pddp/help-line.pd create mode 100644 doc/pddp/help-loadbang.pd create mode 100644 doc/pddp/help-makefilename.pd create mode 100644 doc/pddp/help-math.pd create mode 100644 doc/pddp/help-metro.pd create mode 100644 doc/pddp/help-midi.pd create mode 100644 doc/pddp/help-moses.pd create mode 100644 doc/pddp/help-notein.pd create mode 100644 doc/pddp/help-noteout.pd create mode 100644 doc/pddp/help-operators.pd create mode 100644 doc/pddp/help-otherbinops.pd create mode 100644 doc/pddp/help-pack.pd create mode 100644 doc/pddp/help-pgmin.pd create mode 100644 doc/pddp/help-pgmout.pd create mode 100644 doc/pddp/help-pipe.pd create mode 100644 doc/pddp/help-print.pd create mode 100644 doc/pddp/help-random.pd create mode 100644 doc/pddp/help-realtime.pd create mode 100644 doc/pddp/help-receive.pd create mode 100644 doc/pddp/help-route.pd create mode 100644 doc/pddp/help-select.pd create mode 100644 doc/pddp/help-send.pd create mode 100644 doc/pddp/help-spigot.pd create mode 100644 doc/pddp/help-swap.pd create mode 100644 doc/pddp/help-symbol.pd create mode 100644 doc/pddp/help-tabread.pd create mode 100644 doc/pddp/help-tabread4.pd create mode 100644 doc/pddp/help-tabwrite.pd create mode 100644 doc/pddp/help-timer.pd create mode 100644 doc/pddp/help-trigger.pd create mode 100644 doc/pddp/help-unpack.pd create mode 100644 doc/pddp/help-until.pd create mode 100644 doc/pddp/help-value.pd create mode 100644 doc/pddp/midi-basics.pd create mode 100644 doc/pddp/pddp.pd create mode 100644 doc/pddp/time_measurements.pd diff --git a/doc/pddp/all_about_arrays.pd b/doc/pddp/all_about_arrays.pd new file mode 100644 index 00000000..9ef53ab8 --- /dev/null +++ b/doc/pddp/all_about_arrays.pd @@ -0,0 +1,677 @@ +#N canvas 0 0 653 613 12; +#N canvas 132 0 591 609 What_is_an_array_in_PD 0; +#X text 27 17 WHAT IS AN ARRAY IN PURE DATA?; +#X text 45 42 Arrays \, in most programming environments \, are considered +to be "a sequence of objects all of which have the same variable type" +wherein each object is called an element and the elements are numbered +in a row 0 \, 1 \, 2 \, 3 \, etc. These numbers are called indices. +Each index holds a corresponding value.; +#X text 46 222 Arrays in PD look like this:; +#N canvas 0 0 450 300 graph18 0; +#X array example_array 100 float 0; +#X coords 0 1 99 -1 200 140 1; +#X restore 277 225 graph; +#X text 63 486 1 Right-click on the array and select "Properties" from +the menu. Two dialogue boxes will open - one called "graph" and one +called "array".; +#X text 64 543 2 Then right-click again on the array and select "Help" +from the menu. The window that opens is the table.pd help document. +; +#X text 45 148 All of this is true in PD \, except that arrays in PD +can only hold floating point data. (other data types in PD are called +"lists" or "anythings" and require different tools to manipulate them.) +; +#X text 45 378 The array above is actually only the horizontal line! +The rectangle surrounding the array is called a "graph". These two +objects are separate \, but PD creates both simoultaneously for purposes +of convenience. These two objects together are called a "table". To +see what I mean by all of this:; +#X restore 43 42 pd What_is_an_array_in_PD; +#N canvas 118 1 608 615 How_to_manipulate_arrays_in_PD 0; +#X text 13 5 HOW TO MANIPULATE ARRAYS IN PD; +#N canvas 0 0 452 302 graph28 0; +#X array exampleArray 67 float 0; +#X coords 0 2 67 -2 200 140 1; +#X restore 369 451 graph; +#N canvas 2 29 722 269 Setting_the_size_of_an_array 0; +#X msg 44 88 \; exampleArray resize \$1; +#X floatatom 44 66 5 0 0 0 - - -; +#X text 16 18 1 The size of an array can be set using the array's dialogue +box. Or with a [send] message like below.; +#X text 15 65 2; +#X text 231 91 same as; +#X floatatom 305 66 5 0 0 0 - - -; +#X obj 305 114 s exampleArray; +#X msg 305 88 resize \$1; +#X text 19 158 Note that new elements always have a default value of +zero when you make an array larger. Also note that if you make arrays +smaller \, you may lose data as each element is deleted from the end +of the array.; +#X connect 1 0 0 0; +#X connect 5 0 7 0; +#X connect 7 0 6 0; +#X restore 24 270 pd Setting_the_size_of_an_array; +#N canvas 4 30 720 447 Concatenate_two_arrays 0; +#X text 19 10 This example assumes that we already know the size of +the two arrays which will be concatenated. This process will fill NewArray +with the contents of exampleArray and concatArray.; +#N canvas 0 0 450 300 graph33 0; +#X array concatArray 15 float 1; +#A 0 -0.700355 -0.371783 -0.443212 -0.700355 -0.714641 -0.386069 0.0425035 +0.399647 0.513933 0.399647 0.128218 -0.128925 -0.21464 -0.0289252 -0.700355 +; +#X coords 0 1 14 -1 200 140 1; +#X restore 492 25 graph; +#N canvas 0 0 450 300 graph34 0; +#X array NewArray 82 float 0; +#X coords 0 1 81 -1 300 140 1; +#X restore 389 267 graph; +#X obj 125 66 bng 15 250 50 0 empty empty Bang_me 18 7 0 8 -262144 +-1 -1; +#X obj 28 96 until; +#X obj 28 171 f; +#X obj 58 171 + 1; +#X obj 28 286 tabread exampleArray; +#X obj 28 340 tabwrite NewArray; +#X obj 141 311 tabread concatArray; +#X text 372 194 This example is much more interesting if; +#X text 373 212 you draw new values into each array with; +#X text 373 230 your mouse - then reset and bang again.; +#X obj 150 134 arraysize exampleArray; +#X obj 125 163 arraysize concatArray; +#X obj 125 188 +; +#X msg 178 241 \; NewArray resize \$1; +#X text 28 75 loop; +#X obj 28 219 moses; +#X obj 141 254 -; +#X obj 125 85 t b b b; +#X obj 125 212 t f f; +#X msg 47 144 0; +#X obj 176 109 s clr1; +#X obj 47 119 r clr1; +#X connect 3 0 20 0; +#X connect 4 0 5 0; +#X connect 5 0 6 0; +#X connect 5 0 18 0; +#X connect 5 0 8 1; +#X connect 6 0 5 1; +#X connect 7 0 8 0; +#X connect 9 0 8 0; +#X connect 13 0 15 1; +#X connect 13 0 19 1; +#X connect 13 0 18 1; +#X connect 14 0 15 0; +#X connect 15 0 21 0; +#X connect 18 0 7 0; +#X connect 18 1 19 0; +#X connect 19 0 9 0; +#X connect 20 0 14 0; +#X connect 20 1 13 0; +#X connect 20 2 23 0; +#X connect 21 0 4 0; +#X connect 21 1 16 0; +#X connect 22 0 5 1; +#X connect 24 0 22 0; +#X restore 24 371 pd Concatenate_two_arrays; +#N canvas 4 30 735 395 Join_array_elements_into_a_list 0; +#X text 16 12 JOIN ARRAY ELEMENTS INTO A LIST; +#X obj 22 163 bng 15 250 50 0 empty empty Bang_me 18 7 0 8 -24198 -1 +-1; +#X obj 23 241 until; +#X obj 24 320 tabread exampleArray; +#X obj 216 235 pack s f; +#X obj 216 183 t b f; +#X obj 24 292 f; +#X obj 58 292 + 1; +#X obj 24 348 s \$1-value; +#X obj 216 157 r \$1-value; +#X obj 216 261 route list; +#X obj 519 210 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 519 229 savepanel; +#X msg 519 252 \; exampleArray write \$1; +#X obj 283 353 print; +#X text 289 330 store the list; +#X obj 283 312 textfile; +#X msg 345 285 rewind; +#X obj 216 209 symbol add2; +#X obj 310 240 bng 15 250 50 0 empty empty THEN_Print_the_list 18 7 +0 8 -24198 -1 -1; +#X text 451 308 can be achieved by saving the; +#X text 451 324 array elements to a text file; +#X text 452 341 using the savepanel and write; +#X text 453 357 message.; +#X text 452 292 Alternatively \, a similar result; +#X obj 22 183 arraysize exampleArray; +#X msg 129 261 clear; +#X obj 310 261 t b b; +#X msg 74 260 0; +#X text 29 37 In some other programming environments \, including Visual +Basic and Java (among others) \, there are functions which join all +elements of an array into a list. This example shows how this functionality +can be duplicated in PD. This example uses the elements of exampleArray +from the previous help window. The list can either be printed to the +terminal window \, or it can be saved to a text file.; +#X obj 23 214 t f b; +#X connect 1 0 25 0; +#X connect 2 0 6 0; +#X connect 3 0 8 0; +#X connect 4 0 10 0; +#X connect 5 0 18 0; +#X connect 5 1 4 1; +#X connect 6 0 7 0; +#X connect 6 0 3 0; +#X connect 7 0 6 1; +#X connect 9 0 5 0; +#X connect 10 0 16 0; +#X connect 11 0 12 0; +#X connect 12 0 13 0; +#X connect 16 0 14 0; +#X connect 17 0 16 0; +#X connect 18 0 4 0; +#X connect 19 0 27 0; +#X connect 25 0 30 0; +#X connect 26 0 16 0; +#X connect 27 0 16 0; +#X connect 27 1 17 0; +#X connect 28 0 6 1; +#X connect 30 0 2 0; +#X connect 30 1 28 0; +#X connect 30 1 26 0; +#X restore 24 397 pd Join_array_elements_into_a_list; +#N canvas 2 29 719 337 Getting_the_size_of_an_array 0; +#X text 15 11 GETTING THE SIZE OF AN ARRAY; +#X text 34 34 If you deal with arrays often \, you will want to download +the [arraysize] external written by PIX. PD lacks a native object for +this purpose and I'm afraid that without this external this functionality +is impossible in PD.; +#X obj 38 127 arraysize exampleArray; +#X obj 38 107 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 38 152 5 0 0 0 - - -; +#X text 35 183 Having said that...PD arrays accept a "print" command +which will output important array information to the terminal window. +Like below:; +#X msg 40 258 \; exampleArray print; +#X connect 2 0 4 0; +#X connect 3 0 2 0; +#X restore 24 320 pd Getting_the_size_of_an_array; +#N canvas 0 31 721 390 Reversing_an_array 0; +#X text 20 15 REVERSING AN ARRAY; +#X text 23 35 When an array is reversed \, as the name implies the +first element becomes the last and the last becomes the first. When +viewing this example \, please be sure you can see the "exampleArray" +in the previous window.; +#X obj 110 109 bng 15 250 50 0 empty empty Reverse_me 18 7 0 8 -262144 +-1 -1; +#X obj 110 128 arraysize exampleArray; +#X obj 110 200 until; +#X obj 176 228 + 1; +#X obj 144 228 f; +#X obj 135 176 s \$1-length; +#X obj 169 281 tabread exampleArray; +#X obj 313 342 table tempArray; +#X obj 110 152 t f f f; +#X obj 234 196 s tempArray; +#X msg 234 172 resize \$1; +#X obj 65 308 tabwrite tempArray; +#X obj 510 41 sel; +#X obj 586 31 - 1; +#X obj 586 7 r \$1-length; +#X obj 144 254 t f f f; +#X obj 57 278 s \$1-eof; +#X obj 510 8 r \$1-eof; +#X obj 510 113 until; +#X obj 510 88 f; +#X obj 510 161 f; +#X obj 542 161 - 1; +#X obj 561 108 r \$1-length; +#X obj 529 64 r \$1-length; +#X obj 510 213 tabread tempArray; +#X obj 510 345 tabwrite exampleArray; +#X obj 574 265 f; +#X obj 593 241 r \$1-length; +#X obj 574 314 mod; +#X obj 593 289 r \$1-length; +#X obj 604 265 + 1; +#X obj 510 186 t f b; +#X obj 561 131 - 1; +#X text 13 346 Copies array to a temporary location.; +#X msg 327 124 0; +#X obj 327 148 s clr2; +#X obj 443 150 r clr2; +#X obj 163 200 r clr2; +#X connect 2 0 3 0; +#X connect 2 0 36 0; +#X connect 3 0 10 0; +#X connect 4 0 6 0; +#X connect 5 0 6 1; +#X connect 6 0 5 0; +#X connect 6 0 17 0; +#X connect 8 0 13 0; +#X connect 10 0 4 0; +#X connect 10 1 7 0; +#X connect 10 2 12 0; +#X connect 12 0 11 0; +#X connect 14 0 21 0; +#X connect 15 0 14 1; +#X connect 16 0 15 0; +#X connect 17 0 18 0; +#X connect 17 1 8 0; +#X connect 17 2 13 1; +#X connect 19 0 14 0; +#X connect 20 0 22 0; +#X connect 21 0 20 0; +#X connect 22 0 23 0; +#X connect 22 0 33 0; +#X connect 23 0 22 1; +#X connect 24 0 34 0; +#X connect 25 0 21 1; +#X connect 26 0 27 0; +#X connect 28 0 30 0; +#X connect 28 0 32 0; +#X connect 29 0 28 1; +#X connect 30 0 27 1; +#X connect 31 0 30 1; +#X connect 32 0 28 1; +#X connect 33 0 26 0; +#X connect 33 1 28 0; +#X connect 34 0 22 1; +#X connect 36 0 37 0; +#X connect 38 0 22 1; +#X connect 39 0 6 1; +#X restore 24 474 pd Reversing_an_array; +#N canvas 2 30 719 390 Popping_and_Pushing_arrays 0; +#X obj 62 181 bng 15 250 50 0 empty empty Pop_me -18 -6 0 8 -262144 +-1 -1; +#X obj 134 199 arraysize exampleArray; +#X obj 134 294 tabread exampleArray; +#X floatatom 134 318 0 0 0 0 - - -; +#X obj 99 173 t b b; +#X obj 51 320 - 1; +#X msg 51 346 \; exampleArray resize \$1; +#X floatatom 158 223 0 0 0 0 - - -; +#X text 175 318 value of last element; +#X obj 458 188 bng 15 250 50 0 empty empty Push_me 18 7 0 8 -262144 +-1 -1; +#X text 31 33 I got this idea from Java \, which provides a method +to "pop" an array. The "pop" method will remove the last element in +the array and return its value. The interesting thing about this in +PD is that we need to know the length of the array before we start +(hence another situation where [arraysize] is an essential tool). "Pushing" +is the opposite effect and also a tool provided in Java. When an array +is pushed \, an element is added to the array and the new size is returned. +; +#X obj 458 208 arraysize exampleArray; +#X obj 458 232 + 1; +#X msg 458 292 \; exampleArray resize \$1; +#X floatatom 476 258 0 0 0 0 - - -; +#X text 521 258 new size; +#X text 16 12 POPPING AND PUSHING AN ARRAY; +#X obj 158 246 - 1; +#X text 197 223 # of total elements; +#X floatatom 158 271 0 0 0 0 - - -; +#X text 198 273 new size; +#X connect 0 0 4 0; +#X connect 1 0 2 0; +#X connect 1 0 5 0; +#X connect 1 0 7 0; +#X connect 2 0 3 0; +#X connect 4 0 5 0; +#X connect 4 1 1 0; +#X connect 5 0 6 0; +#X connect 7 0 17 0; +#X connect 9 0 11 0; +#X connect 11 0 12 0; +#X connect 12 0 13 0; +#X connect 12 0 14 0; +#X connect 17 0 19 0; +#X restore 24 423 pd Popping_and_Pushing_arrays; +#N canvas 2 30 722 391 Shifting_an_array 0; +#X obj 30 90 bng 15 250 50 0 empty empty Shift_me 18 7 0 8 -24198 -1 +-1; +#X text 16 12 SHIFTING AN ARRAY; +#X text 20 32 The shift method \, in Java \, will remove the first +element of the array and return its value. This is opposite of the +"Pop" method which removes the last element.; +#X obj 30 272 tabread exampleArray; +#X obj 30 354 tabwrite tempArray2; +#X obj 551 11 table tempArray2; +#X obj 30 110 arraysize exampleArray; +#X msg 225 160 \; tempArray2 resize \$1; +#X obj 30 163 until; +#X obj 30 215 f; +#X obj 62 215 + 1; +#X obj 30 136 t f f f; +#X obj 129 167 s \$1-length; +#X obj 160 301 spigot; +#X obj 203 276 < 1; +#X floatatom 160 328 5 0 0 0 - - -; +#X text 209 327 First value.; +#X text 208 345 ...to be deleted.; +#X obj 304 239 - 1; +#X obj 304 212 r \$1-length; +#X obj 30 239 t f f f f; +#X obj 285 263 sel; +#X obj 285 288 s \$2-eof; +#X obj 427 71 r \$2-eof; +#X obj 427 95 t b b; +#X msg 419 304 \; tempArray2 resize \$1 \; exampleArray resize \$1 +; +#X obj 401 256 r \$1-length; +#X obj 401 280 - 1; +#X obj 382 304 f; +#X obj 497 128 until; +#X obj 497 102 f; +#X obj 551 69 r \$1-length; +#X obj 529 155 + 1; +#X obj 574 156 r \$1-length; +#X obj 497 184 mod; +#X obj 497 155 f 1; +#X obj 497 209 t f f; +#X obj 497 257 tabread tempArray2; +#X obj 497 281 tabwrite exampleArray; +#X obj 551 93 - 1; +#X obj 574 179 - 1; +#X obj 497 234 + 1; +#X msg 223 105 0; +#X msg 588 118 1; +#X obj 223 129 s clr; +#X obj 588 94 r clr; +#X obj 49 188 r clr; +#X connect 0 0 6 0; +#X connect 0 0 42 0; +#X connect 3 0 4 0; +#X connect 3 0 13 0; +#X connect 6 0 11 0; +#X connect 8 0 9 0; +#X connect 9 0 10 0; +#X connect 9 0 20 0; +#X connect 10 0 9 1; +#X connect 11 0 8 0; +#X connect 11 1 12 0; +#X connect 11 2 7 0; +#X connect 13 0 15 0; +#X connect 14 0 13 1; +#X connect 18 0 21 1; +#X connect 19 0 18 0; +#X connect 20 0 3 0; +#X connect 20 1 4 1; +#X connect 20 2 14 0; +#X connect 20 3 21 0; +#X connect 21 0 22 0; +#X connect 23 0 24 0; +#X connect 24 0 28 0; +#X connect 24 1 30 0; +#X connect 26 0 27 0; +#X connect 27 0 28 1; +#X connect 28 0 25 0; +#X connect 29 0 35 0; +#X connect 30 0 29 0; +#X connect 31 0 39 0; +#X connect 32 0 35 1; +#X connect 33 0 40 0; +#X connect 34 0 36 0; +#X connect 35 0 32 0; +#X connect 35 0 34 0; +#X connect 36 0 41 0; +#X connect 36 1 38 1; +#X connect 37 0 38 0; +#X connect 39 0 30 1; +#X connect 40 0 34 1; +#X connect 41 0 37 0; +#X connect 42 0 44 0; +#X connect 43 0 35 1; +#X connect 45 0 43 0; +#X connect 46 0 9 1; +#X restore 24 449 pd Shifting_an_array; +#X text 25 32 Arrays in PD are different than the arrays in other languages +primarily because \, in PD \, they are designed to be displayed graphically +on screen. This is due to the nature of audio synthesis - we want to +see our wave forms and visually understand the data. That's why arrays +in PD are complicated by other objects like tables \, graphs and widgets. +PD uses these objects to provide a graphic representation of the array +data. If you're not interested in seeing the array data within your +PD patch \, you can use the [table] object to store the array and corresponding +table in a sub-window. Note that [table]s are more CPU friendly than +their graphical counterpart.; +#X text 26 230 Like all programming languages \, PD provides numerous +tools to manipulate arrays and their data.; +#N canvas 3 32 718 310 Setting_a_constant_array_value 0; +#X floatatom 26 151 0 0 0 0 - - -; +#X obj 26 185 / 100; +#X msg 26 215 \; exampleArray const \$1; +#X text 18 16 SETTING A CONSTANT ARRAY VALUE; +#X text 27 46 By default \, all array element values are zero. However +\, PD allows you to change that using the "CONST" message.; +#X text 26 88 This feature is useful to reset all values in an array +\, or with a little creativity can be used to "delete" a slice \, or +create silence in audio samples.; +#X connect 0 0 1 0; +#X connect 1 0 2 0; +#X restore 24 345 pd Setting_a_constant_array_value; +#N canvas 3 26 727 395 Higher_math_using_arrays 0; +#X text -7 12 HIGHER MATH USING ARRAYS; +#X text -3 226 Normalize; +#X text 78 227 (arg: renormer...a number by which all array values +will be normalized); +#X msg 6 278 \; exampleArray normalize \$1; +#X floatatom 6 256 5 0 0 0 - - -; +#N canvas 5 55 710 432 sine_waves 0; +#X text 34 188 Sinesum; +#X text 98 190 (arg 1: Number of Points - arg 2: list of partial strengths) +; +#X msg 40 293 \; exampleArray sinesum 64 1 0 0.5 0 0.2 0 0.15; +#X msg 40 251 \; exampleArray sinesum 64 1 0.5 0.38 0.3 0.28 0.25 0.2 +; +#X msg 40 210 \; exampleArray sinesum 64 1; +#X text 26 7 SINE WAVES; +#X text 29 30 comment; +#X text 45 29 When the "sinesum" message is sent to the array \, PD +will want to know two things:; +#X text 58 65 1 How many samples (array elements) should be used? The +higher the number is \, the higher the resolution of the wave form. +; +#X text 58 122 2 What is the relative strength of each "partial" or +"overtone" in the sound? For more info about this \, please lookup +"overtones" or "harmonics" or "partials" on the internet.; +#X text 250 220 a pure sine wave!; +#X text 479 259 a triangle wave; +#X text 412 303 a square wave; +#X text 33 346 Note that these waves aren't exactly triangular or square...instead +they are "smoothed" by the sinesum function to more accurately produce +these wave forms as analog instruments do.; +#X restore 7 42 pd sine_waves; +#X text 141 26 Audio signals in a digital realm are created using a +series of samples. It is digitally possible to create extremely angular +wave forms using PD arrays \, but the aural result is sometimes distorted +and unpleasant. Hence \, higher math functions help our digital tools +to produce data which can effectively be converted to analog signals +similar to those of our electronic and mechanical predecessors. The +first and one of the most important mathematic functions in digital +synthesis is undoubtebly "sinesum". PD provides an easy method for +us to integrate these higher math functions in our arrays.; +#N canvas 0 195 750 302 cosine_waves 0; +#X text 11 22 Cosinesum; +#X text 91 22 (arg 1: Number of Points - arg 2: list of partial strengths) +; +#X text 273 84 pure cosine wave!; +#X msg 23 117 \; exampleArray cosinesum 64 0 -0.5 0 -0.2 0.1 0; +#X msg 24 76 \; exampleArray cosinesum 64 0 1; +#X msg 22 159 \; exampleArray cosinesum 64 -0.15 0.2 0.15 -0.15 0.1 +0.1 0.2 -0.2 0.35 -0.25 -0.1 0.1 0.199; +#X restore 6 73 pd cosine_waves; +#X text 222 257 To normalize an audio signal means to alter the average +amplitude of the signal. For the sake of clear \, undistored sounds +\, PD would like all of your audio signals to never exceed 1 or -1 +The first step in achieving this is "normalization" \, but can be assisted +by more drastic tools like compressors \, limiters \, gain multipliers +\, etc.; +#X connect 4 0 3 0; +#X restore 24 499 pd Higher_math_using_arrays; +#N canvas 2 31 727 416 Files_and_arrays 0; +#X text 24 14 OTHER IMPORTANT STUFF; +#X obj 225 91 savepanel; +#X obj 225 70 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X msg 225 117 \; exampleArray write \$1; +#X obj 475 70 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 475 89 openpanel; +#X msg 475 113 \; exampleArray read \$1; +#X text 26 29 Using text files can be helpful in saving or loading +arrays in PD. Note that the "read" message does not resize your array +automatically.; +#X text 29 160 Audio files can be treated in similar ways by incorporating +the [soundfiler] object. The soundfiler object provides PD with tools +to automatically resize arrays \, and read/write audio files in a variety +of formats.; +#X obj 77 231 openpanel; +#X obj 52 232 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 4 280 symbol read; +#X obj 54 380 soundfiler; +#X obj 54 355 route list; +#X obj 54 332 pack s s s s; +#X obj 100 280 symbol -resize; +#X obj 78 254 t b b s b; +#X obj 145 305 symbol exampleArray; +#X obj 373 231 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 375 378 soundfiler; +#X obj 375 353 route list; +#X obj 375 330 pack s s s s; +#X obj 399 253 t b b s b; +#X obj 466 303 symbol exampleArray; +#X obj 398 230 savepanel; +#X obj 317 278 symbol write; +#X obj 421 278 symbol -aiff; +#X connect 1 0 3 0; +#X connect 2 0 1 0; +#X connect 4 0 5 0; +#X connect 5 0 6 0; +#X connect 9 0 16 0; +#X connect 10 0 9 0; +#X connect 11 0 14 0; +#X connect 13 0 12 0; +#X connect 14 0 13 0; +#X connect 15 0 14 1; +#X connect 16 0 11 0; +#X connect 16 1 15 0; +#X connect 16 2 14 2; +#X connect 16 3 17 0; +#X connect 17 0 14 3; +#X connect 18 0 24 0; +#X connect 20 0 19 0; +#X connect 21 0 20 0; +#X connect 22 0 25 0; +#X connect 22 1 26 0; +#X connect 22 2 21 2; +#X connect 22 3 23 0; +#X connect 23 0 21 3; +#X connect 24 0 22 0; +#X connect 25 0 21 0; +#X connect 26 0 21 1; +#X restore 24 526 pd Files_and_arrays; +#N canvas 0 0 719 423 Additional_tools 0; +#X text 18 14 ADDITIONAL TOOLS; +#X text 29 38 The "array" object in PD accepts special messages to +alter the appearance of the array on screen.; +#X text 19 81 Arrays can be renamed:; +#X msg 203 78 \; exampleArray rename george; +#X msg 431 78 \; george rename exampleArray; +#X msg 303 173 \; exampleArray bounds 0 1 67 -1; +#X text 20 129 You can set the bounds of the rectangle: (the arguments +are:; +#X text 353 146 low x \, high y \, high x \, low y); +#X msg 58 173 \; exampleArray bounds 0 2 67 -2; +#X text 18 219 Array graphs can be given "ticks" on both the x and +y axis to help you visually measure your data. The tick messages require +3 values: (the index or value of the FIRST large tick \, then the interval +between ticks \, then finally the number of ticks overall per large +tick).; +#X msg 488 243 \; exampleArray xticks 0 5 3; +#X msg 471 290 \; exampleArray yticks 0 0.5 4; +#X msg 354 369 \; exampleArray ylabel -5 -2 -1.5 -1 1 1.5 2; +#X msg 26 369 \; exampleArray xlabel 0 10 20 30 40 50 60; +#X text 17 325 Arrays can be given labels to describe the x and y axis. +Give a y value and a bunch of x values or vice versa:; +#X restore 24 553 pd Additional_tools; +#N canvas 4 29 717 375 Populating_an_array 0; +#X text 27 12 POPULATING AN ARRAY; +#X text 41 37 An array in PD is primarily a storage device for numbers. +The result is a series of numbers that you can do with whatever you +wish...but how does one populate an array?; +#X text 53 185 list element 1 = array[0]; +#X text 53 201 list element 2 = array[1]; +#X text 39 94 Advanced techniques using text or audio files is described +later \, but for now it's important to know that you can send an array +a list. Each element in the list will be assigned to the corresponding +element in the array. Note that the first index in an array is always +zero!; +#X msg 39 303 \; exampleArray 0 -1 1 -1 0.5 -0.5 0.5 -0.2 0.2 -0.2 +0.1 -0.1 0; +#X text 37 232 Note that if your array is larger than your list \, +then only the first elements will be effected. If your array is smaller +than your list \, then your list will be truncated.; +#X restore 24 295 pd Populating_an_array; +#X restore 41 173 pd How_to_manipulate_arrays_in_PD; +#N canvas 132 0 587 609 How_to_create_an_array_in_PD 0; +#X text 22 9 1 Select "array" from the "Put" menu above.; +#X text 21 288 4 If you want PD to create a new graph for this array +\, then select "in new graph". If you have another location in mind +-- for example if you want to overlap two arrays in a single graph +\, then select "in last graph".; +#X text 19 361 5 Then click "OK" and place the new array anywhere in +this window.; +#X text 19 403 6 Note: if you do not want to see the graph in this +window \, then you can use the [table] object instead...the array will +then be created inside the [table] object and will be seen only if +you manually open the table.; +#X text 22 31 2 A dialogue box appears where you can type the name +of the array and the desired size. Names can be anything you want - +if you want a localized array \, then name it something like \$1-dave +(the dollar sign indicates that part of the name is a variable which +is unique to this patch). The size of the array can be anything greater +than 0 (zero). At a sample rate of 441000 khz \, an array of 882000 +will provide you with 2 seconds of audio data.; +#X text 21 167 3 The "Save contents" checkbox will inform Pure Data +that you want the array saved within the source code of this patch. +This way \, you can ensure that the array will maintain its values +each time you open this patch. This is recommended only for relatively +small arrays...larger arrays should be saved to either a text file +\, or an audio file.; +#X restore 42 106 pd How_to_create_an_array_in_PD; +#N canvas 133 1 646 607 Common_uses_for_arrays_in_PD 0; +#X text 27 26 COMMON USES FOR ARRAYS IN PD; +#X text 49 60 Arrays are versatile. Their simple structure make them +useful in countless situations. This page discusses perhaps the most +common applications.; +#X text 50 225 2 MIDI Sequencers: array values limited to a range between +0 and 127 are suitable for MIDI output to be used as pitch \, velocity +\, or controller numbers. Some MIDI information requires a much larger +range \, such as pitch benders.; +#X text 50 306 3 Envelopes: an array with four elements can be used +effectively as an ADSR enveloper. There are numerous examples of this +in other PD help documents.; +#X text 53 377 4 Math and conversion tables: arrays are an excellent +visual tool when performing fourier analysis and other higher mathematic +functions.; +#X text 54 450 5 Wave editing: with proper manipulation of array data +\, PD can be fully functional wave editor \, complete with mouse-clickable +cut-n-paste \, pitch-shift \, time expansion \, down/upsampling \, +and other tools typically found in commercial wave editors.; +#X text 49 128 1 Audio sample data: when an array's values are limited +to a range between -1 and 1 \, the numbers are suitable for conversion +to analog audio signal. These arrays are typically many thousands of +elements and stored on hard disk in the form of aiff \, wav or pure +text.; +#X restore 40 239 pd Common_uses_for_arrays_in_PD; +#X text 39 309 NOTE: I strongly recommend that you download the [arraysize] +external to your "pd/extra" folder before continuing. Some of these +examples are impossible without it -- I personally feel that [arraysize] +should be considered for permanent inclusion in future PD distributions. +Check the CVS Repository or Pure-data.org for [arraysize].; +#X text 40 459 This document is meant to supplement the help documentation +for [table] \, [tabread] \, [tabwrite] \, [soundfiler] \, [tabsend~] +\, [tabreceive~] \, [tabplay~] \, etc.; diff --git a/doc/pddp/help-acoustics.pd b/doc/pddp/help-acoustics.pd new file mode 100644 index 00000000..094b47b4 --- /dev/null +++ b/doc/pddp/help-acoustics.pd @@ -0,0 +1,583 @@ +#N canvas 22 16 828 633 10; +#X obj 12 58 mtof; +#X floatatom 12 81 0 0 0; +#X obj 12 105 ftom; +#X floatatom 12 126 0 0 0; +#X text 46 11 ACOUSTIC CONVERSIONS; +#X text 47 58 -- MIDI note number to frequency converter.; +#N canvas 37 -4 899 659 understanding_mtof 0; +#X text 20 13 [mtof] will convert MIDI note numbers to Wave Freqeuency. +This object exists in PD for the sake of convenience and speed of processing. +; +#X obj 37 165 mtof; +#X floatatom 37 143 5 0 0; +#X text 77 142 Select a MIDI note: (Middle C is 60).; +#X floatatom 37 188 5 0 0; +#X obj 37 207 osc~; +#X floatatom 99 203 0 0 0; +#N canvas 397 146 628 393 output 0; +#X obj 393 156 t b; +#X obj 393 106 f; +#X obj 393 56 inlet; +#X text 399 25 mute; +#X obj 393 181 f; +#X msg 480 174 0; +#X msg 393 81 bang; +#X obj 393 131 moses 1; +#X obj 480 149 t b f; +#X obj 452 113 moses 1; +#X obj 138 144 dbtorms; +#X obj 452 88 r master-lvl; +#X obj 138 38 r master-lvl; +#X obj 393 206 s master-lvl; +#X obj 22 181 inlet~; +#X obj 254 37 inlet; +#X text 254 14 level; +#X obj 254 152 s master-lvl; +#X msg 151 61 set \$1; +#X obj 151 85 outlet; +#X obj 138 190 line~; +#X obj 22 212 *~; +#X obj 138 167 pack 0 50; +#X text 34 159 audio; +#X text 148 106 show level; +#X obj 73 182 inlet~; +#X obj 73 213 *~; +#X obj 22 241 dac~ 1; +#X obj 73 241 dac~ 2; +#X msg 290 82 1; +#X obj 265 59 sel 0; +#X msg 265 119 \; pd dsp \$1; +#X msg 265 82 0; +#X connect 0 0 4 0; +#X connect 1 0 7 0; +#X connect 2 0 6 0; +#X connect 4 0 13 0; +#X connect 5 0 13 0; +#X connect 5 0 31 0; +#X connect 6 0 1 0; +#X connect 7 0 0 0; +#X connect 7 1 8 0; +#X connect 8 0 5 0; +#X connect 9 1 4 1; +#X connect 10 0 22 0; +#X connect 11 0 1 1; +#X connect 11 0 9 0; +#X connect 12 0 10 0; +#X connect 12 0 18 0; +#X connect 14 0 21 0; +#X connect 15 0 17 0; +#X connect 15 0 30 0; +#X connect 18 0 19 0; +#X connect 20 0 21 1; +#X connect 20 0 26 1; +#X connect 21 0 27 0; +#X connect 22 0 20 0; +#X connect 25 0 26 0; +#X connect 26 0 28 0; +#X connect 29 0 31 0; +#X connect 30 0 32 0; +#X connect 30 1 29 0; +#X connect 32 0 31 0; +#X restore 37 232 pd output; +#X msg 128 204 MUTE; +#X text 164 203 <-- Turn up your volume here.; +#X text 15 260 HERE IS THE ALTERNATIVE; +#X obj 36 321 mtof; +#X floatatom 36 281 5 0 0; +#X floatatom 15 345 0 0 0; +#X floatatom 123 461 0 0 0; +#X obj 138 312 <= -1500; +#X obj 138 332 expr 1-$f1; +#X obj 95 352 spigot; +#X obj 95 295 t f f; +#X obj 95 372 min 1499; +#X obj 95 419 expr (8.17579891564*exp(0.0577622650*$f1)); +#X obj 151 352 s zero; +#X obj 123 440 r zero; +#X obj 96 485 bang; +#X obj 36 482 bang; +#X obj 36 502 realtime; +#X floatatom 161 576 0 0 0; +#X obj 204 499 bang; +#X obj 161 499 bang; +#X obj 161 519 realtime; +#X floatatom 161 540 0 0 0; +#X obj 365 389 *; +#X obj 408 342 loadbang; +#X obj 365 408 exp; +#X obj 365 428 *; +#X floatatom 365 448 0 0 0; +#X obj 397 431 r zero; +#X text 79 277 Select a MIDI note here.; +#X obj 477 572 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 477 12 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 496 123 The examples at the botton left are PD structures which +emulate the source code of the [mtof] object. In one case \, I have +used the [expr] object to perform the necessary calculation. In the +other case \, I used PD's Arithmetic objects to perform the calculation. +; +#X text 498 291 Secondly \, the incoming MIDI note number is translated +into a frequency value by the simple equation:; +#X text 494 330 (8.17579891564 * exp(0.0577622650 * MIDI_note)) = frequency +; +#X text 498 355 For curiosity's sake \, I included a timer to show +how much faster the [mtof] object is compared to the two alternative +methods.; +#X text 162 556 Arithmetic is __?__ milliseconds slower than [mtof]. +; +#X text 159 592 [expr] is __?__ milliseconds slower than [mtof].; +#X text 12 363 RESULT A; +#X text 123 476 RESULT B; +#X text 364 465 RESULT C; +#X msg 408 363 0.0577623; +#X msg 408 403 8.1758; +#X text 504 12 THE ALTERNATIVE EXPLAINED; +#X text 499 33 The [mtof] object is really just a function defined +in PD's source code - which is programmed in "C".; +#X text 497 67 As such \, it operates very quickly. If a similar function +were to be created using PD's arithmetic objects \, the process would +be quite a bit slower. How much slower?; +#X text 498 409 As well \, notice that RESULT C (the output from PD's +basic arithmetic objects) is not as accurate as the other two methods: +[mtof] and/or [expr]. This is because the message boxes and the [*] +object round off the operands because they cannot handle enough decimal +places.; +#X text 498 200 The first order of business performed by these examples +is the filtering out of all numbers less than -1500 and greater than +1499 (Just like the [mtof] source code). In other words \, "overflows +and underflows are clipped" as Miller Puckette stated in the original +documentation for this object.; +#X text 22 62 MIDI notes usually range between 0 and 127 from an incoming +MIDI controller. However \, in PD negative numbers to -1500 and positive +numbers to 1499 are also supported and decimal places can be used to +achive microtonal pitches.; +#X text 11 125 CONVENIENT? YES!; +#X connect 1 0 4 0; +#X connect 2 0 1 0; +#X connect 4 0 5 0; +#X connect 5 0 7 0; +#X connect 6 0 7 2; +#X connect 7 0 6 0; +#X connect 8 0 7 3; +#X connect 11 0 13 0; +#X connect 11 0 24 0; +#X connect 12 0 11 0; +#X connect 12 0 18 0; +#X connect 15 0 16 0; +#X connect 16 0 17 1; +#X connect 16 0 21 0; +#X connect 17 0 19 0; +#X connect 18 0 17 0; +#X connect 18 1 15 0; +#X connect 19 0 20 0; +#X connect 19 0 23 0; +#X connect 19 0 31 0; +#X connect 20 0 14 0; +#X connect 22 0 14 0; +#X connect 23 0 25 1; +#X connect 24 0 25 0; +#X connect 24 0 28 0; +#X connect 25 0 26 0; +#X connect 27 0 29 1; +#X connect 28 0 29 0; +#X connect 29 0 30 0; +#X connect 31 0 33 0; +#X connect 32 0 49 0; +#X connect 32 0 50 0; +#X connect 33 0 34 0; +#X connect 34 0 35 0; +#X connect 34 0 27 0; +#X connect 36 0 35 0; +#X connect 39 0 38 0; +#X connect 49 0 31 1; +#X connect 50 0 34 1; +#X restore 175 75 pd understanding_mtof; +#X text 47 105 -- Frequency to MIDI note number converter.; +#N canvas 118 -18 919 630 understanding_ftom 0; +#X floatatom 38 86 5 0 0; +#X floatatom 38 131 5 0 0; +#X text 12 215 HERE IS THE ALTERNATIVE; +#X floatatom 33 236 5 0 0; +#X floatatom 12 300 0 0 0; +#X obj 507 572 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 507 12 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 9 318 RESULT A; +#X text 534 12 THE ALTERNATIVE EXPLAINED; +#X text 527 67 As such \, it operates very quickly. If a similar function +were to be created using PD's arithmetic objects \, the process would +be quite a bit slower. How much slower?; +#X text 12 68 CONVENIENT? YES!; +#X text 22 14 [ftom] will convert Wave/Signal Frequency to MIDI note +numbers. This object exists in PD for the sake of convenience and speed +of processing.; +#X text 78 85 Select a Frequency: (i.e. 440 hz is an "A" above middle +C); +#X obj 38 108 ftom; +#X obj 38 158 makenote 100 500; +#X obj 38 181 noteout; +#X text 76 232 Select a FREQUENCY here.; +#X obj 33 276 ftom; +#X text 529 33 The [ftom] object is really just a function defined +in PD's source code - which is programmed in "C".; +#X text 526 123 The examples at the botton left are PD structures which +emulate the source code of the [ftom] object. In one case \, I have +used the [expr] object to perform the necessary calculation. In the +other case \, I used PD's Arithmetic objects to perform the calculation. +; +#X obj 64 256 moses 0; +#X msg 64 277 -1500; +#X floatatom 64 408 0 0 0; +#X floatatom 114 346 0 0 0; +#X obj 114 313 * 17.3123; +#X obj 114 273 * 0.122312; +#X obj 114 293 log; +#X obj 101 385 expr (17.3123405046*log(.12231220585*$f1)); +#X text 64 423 RESULT B; +#X text 113 359 RESULT C; +#X obj 93 449 bang; +#X obj 33 446 bang; +#X obj 33 466 realtime; +#X floatatom 158 540 0 0 0; +#X obj 201 463 bang; +#X obj 158 463 bang; +#X obj 158 483 realtime; +#X floatatom 158 504 0 0 0; +#X text 189 520 Arithmetic is __?__ milliseconds slower than [mtof]. +; +#X text 156 556 [expr] is __?__ milliseconds slower than [mtof].; +#X text 528 200 Firstly \, the PD source code "clips" overflows and +underflows. This means simply that frequencies LESS THAN zero cannot +be tranlated into a MIDI note value - so they're ignored completely +and the object responds with "-1500".; +#X text 528 291 Secondly \, the incoming frequency is translated into +a MIDI note value by the simple equation:; +#X text 524 330 (17.3123405046 * log(0.12231220585 * Frequency)) = +MIDI_note; +#X text 528 355 For curiosity's sake \, I included a timer to show +how much faster the [ftom] object is compared to the two alternative +methods.; +#X text 528 409 As well \, notice that RESULT C (the output from PD's +basic arithmetic objects) is not as accurate as the other two methods: +[ftom] and/or [expr]. This is because the message boxes and the [*] +object round off the operands because they cannot handle enough decimal +places.; +#X text 145 119 Note that fractional values have no effect. MIDI controllers +only accept integers. Perhaps a subroutine could be designed to parse +the decimal places and manipulate the pitch bend controller to achieve +microtonal control?; +#X connect 0 0 13 0; +#X connect 1 0 14 0; +#X connect 3 0 17 0; +#X connect 3 0 20 0; +#X connect 4 0 31 0; +#X connect 6 0 5 0; +#X connect 13 0 1 0; +#X connect 14 0 15 0; +#X connect 14 1 15 1; +#X connect 17 0 4 0; +#X connect 20 0 21 0; +#X connect 20 1 25 0; +#X connect 20 1 27 0; +#X connect 21 0 22 0; +#X connect 21 0 23 0; +#X connect 22 0 30 0; +#X connect 23 0 34 0; +#X connect 24 0 23 0; +#X connect 25 0 26 0; +#X connect 26 0 24 0; +#X connect 27 0 22 0; +#X connect 30 0 32 1; +#X connect 31 0 32 0; +#X connect 31 0 35 0; +#X connect 32 0 33 0; +#X connect 34 0 36 1; +#X connect 35 0 36 0; +#X connect 36 0 37 0; +#X restore 174 121 pd understanding_ftom; +#X floatatom 12 37 0 0 0; +#X floatatom 12 207 0 0 0; +#X floatatom 12 252 0 0 0; +#X floatatom 12 163 0 0 0; +#X obj 12 184 dbtorms; +#X obj 12 231 rmstodb; +#N canvas 65 78 423 452 understanding_dbtorms 0; +#N canvas 0 0 452 302 What_is_a_decibel? 0; +#X text 24 94 The difficulty in measuring the volume of an instrument +however is caused by 'distance'. For example \, at one metre away from +a door bell \, the amplitude might be 70 Decibels \, while at 50 metres +away the same door bell is just a fraction of that amplitude.; +#X text 25 33 DECIBELS are units by which we measure amplitude. A human +voice is approximately 70 Decibels - a snare drum is approximately +120 Decibels - the threshold of pain for the human ear is approximately +110 Decibels (poor drummers!); +#X text 23 174 Literally \, a Decibel is one-tenth of a Bel. A Bel +\, according to a medical dictionary is approximately the threshold +of the human ear at 1000 hz. I know that this seems a little vague +\, and perhaps this isn't the best way to explain it - we might as +well be measuring "fortnights" and "bunches" and "Alens"! Anyways...I'm +not an acoustician.; +#X restore 39 24 pd What_is_a_decibel?; +#N canvas 0 0 440 242 What_does_RMS_mean? 0; +#X text 24 21 RMS is an acronym meaning "Root Mean Square".; +#X text 23 43 In the analog realm \, RMS is the result of an equation +performed on electrical flow. It is used to measure voltage or current. +It is important to note however \, that it does NOT measure "power". +It's also important to recognize that our ears perceive changes in +amplitude (decibels) more than we perceive changes in RMS levels.; +#X text 23 133 In the digital realm \, i.e. PD! \, RMS is better defined +as "a measurement of a signal taken by squaring data points along the +curve \, finding the mean \, and then determining the square root of +that mean value.; +#X restore 39 47 pd What_does_RMS_mean?; +#X text 19 80 [dbtorms] in PD performs the following equation to convert +the data: Note that incoming values less than 0 or greater than 485 +are considered overflow or underflow and are clipped/ignored.; +#X text 22 241 Example:; +#X floatatom 24 293 0 0 0; +#X obj 24 313 moses 0; +#X msg 24 333 0; +#X obj 86 352 min 485; +#X text 17 149 (exp((2.302585092994 * 0.05) * (db_value - 100)) = RMS +; +#X floatatom 24 397 0 0 0; +#X obj 151 310 dbtorms; +#X floatatom 151 330 0 0 0; +#X obj 86 372 expr (exp((2.302585092994*0.05)*($f1-100))); +#X text 18 178 On a scale of zero to 100 decibels \, the [dbtorms] +produces exponential values between 0 and 1; +#X msg 24 264 0; +#X msg 57 264 100; +#X obj 61 332 sel 0; +#X connect 4 0 5 0; +#X connect 4 0 10 0; +#X connect 5 0 6 0; +#X connect 5 1 16 0; +#X connect 6 0 9 0; +#X connect 7 0 12 0; +#X connect 10 0 11 0; +#X connect 12 0 9 0; +#X connect 14 0 4 0; +#X connect 15 0 4 0; +#X connect 16 0 6 0; +#X connect 16 1 7 0; +#X restore 155 203 pd understanding_dbtorms; +#X text 66 185 -- Decibels to RMS converter.; +#X text 66 232 -- RMS to Decibels converter.; +#X floatatom 12 333 0 0 0; +#X floatatom 12 378 0 0 0; +#X floatatom 12 289 0 0 0; +#X obj 12 310 dbtopow; +#X obj 12 357 powtodb; +#N canvas 349 60 423 452 understanding_rmstodb 0; +#N canvas 0 0 452 302 What_is_a_decibel? 0; +#X text 24 94 The difficulty in measuring the volume of an instrument +however is caused by 'distance'. For example \, at one metre away from +a door bell \, the amplitude might be 70 Decibels \, while at 50 metres +away the same door bell is just a fraction of that amplitude.; +#X text 25 33 DECIBELS are units by which we measure amplitude. A human +voice is approximately 70 Decibels - a snare drum is approximately +120 Decibels - the threshold of pain for the human ear is approximately +110 Decibels (poor drummers!); +#X text 23 174 Literally \, a Decibel is one-tenth of a Bel. A Bel +\, according to a medical dictionary is approximately the threshold +of the human ear at 1000 hz. I know that this seems a little vague +\, and perhaps this isn't the best way to explain it - we might as +well be measuring "fortnights" and "bunches" and "Alens"! Anyways...I'm +not an acoustician.; +#X restore 39 24 pd What_is_a_decibel?; +#N canvas 0 0 440 242 What_does_RMS_mean? 0; +#X text 24 21 RMS is an acronym meaning "Root Mean Square".; +#X text 23 43 In the analog realm \, RMS is the result of an equation +performed on electrical flow. It is used to measure voltage or current. +It is important to note however \, that it does NOT measure "power". +It's also important to recognize that our ears perceive changes in +amplitude (decibels) more than we perceive changes in RMS levels.; +#X text 23 133 In the digital realm \, i.e. PD! \, RMS is better defined +as "a measurement of a signal taken by squaring data points along the +curve \, finding the mean \, and then determining the square root of +that mean value.; +#X restore 39 47 pd What_does_RMS_mean?; +#X text 22 219 Example:; +#X floatatom 24 259 0 0 0; +#X floatatom 24 422 0 0 0; +#X floatatom 151 354 0 0 0; +#X msg 68 278 0; +#X text 19 80 [rmstodb] in PD performs the following equation to convert +the data: Note that incoming values less than 0 is consider underflow +and is clipped/ignored.; +#X text 18 178 On a scale of zero to 1 decibels \, the [rmstodb] produces +logarithmic values between 0 and 100 \, although higher values can +also be produced.; +#X obj 151 334 rmstodb; +#X obj 24 358 max 0; +#X obj 24 401 max 0; +#X obj 24 379 expr (100+((20/2.302585092994)*log($f1))); +#X text 18 136 (100 + ((20/2.302585092994) * log(RMS_value))); +#X obj 24 278 / 1000; +#X floatatom 24 310 0 0 0; +#X msg 101 278 1; +#X connect 3 0 14 0; +#X connect 6 0 15 0; +#X connect 9 0 5 0; +#X connect 10 0 12 0; +#X connect 11 0 4 0; +#X connect 12 0 11 0; +#X connect 14 0 15 0; +#X connect 15 0 9 0; +#X connect 15 0 10 0; +#X connect 16 0 15 0; +#X restore 153 249 pd understanding_rmstodb; +#X text 66 311 -- Decibels to power converter.; +#X text 66 358 -- power to Decibels converter.; +#X text 439 17 Please note: I have no idea why it's necessary for PD +to measure decibels \, rms \, or power. It seems to me that RMS and +Power are extremely important in the analog world (so that an engineer +doesn't blow up a transistor)...but in PD \, these things are just +numbers which have been abstracted from their original analog counterparts. +I would really appreciate if somebody could help me understand these +concepts and finish this document. Why are these objects present in +PD? WHY should they be used and what benefits to they produce in a +digital process?; +#N canvas 460 106 429 458 understanding_dbtopow 0; +#N canvas 0 0 452 302 What_is_a_decibel? 0; +#X text 24 94 The difficulty in measuring the volume of an instrument +however is caused by 'distance'. For example \, at one metre away from +a door bell \, the amplitude might be 70 Decibels \, while at 50 metres +away the same door bell is just a fraction of that amplitude.; +#X text 25 33 DECIBELS are units by which we measure amplitude. A human +voice is approximately 70 Decibels - a snare drum is approximately +120 Decibels - the threshold of pain for the human ear is approximately +110 Decibels (poor drummers!); +#X text 23 174 Literally \, a Decibel is one-tenth of a Bel. A Bel +\, according to a medical dictionary is approximately the threshold +of the human ear at 1000 hz. I know that this seems a little vague +\, and perhaps this isn't the best way to explain it - we might as +well be measuring "fortnights" and "bunches" and "Alens"! Anyways...I'm +not an acoustician.; +#X restore 39 24 pd What_is_a_decibel?; +#X floatatom 21 205 0 0 0; +#X floatatom 21 309 0 0 0; +#X floatatom 148 242 0 0 0; +#N canvas 0 0 442 244 What_does_power_mean? 0; +#X text 30 25 What does power mean? I really don't know? I can't determine +from my own research or from PD's documentation why or how this data +is used. All that I do know \, is that PD provides these objects for +a good reason -- I just don't know the reason.; +#X text 27 103 Having said that \, I would enjoy learning from somebody +who DOES know more about these objects and their usage. All that I +can offer is an explanation of the equation used to perform these conversions. +; +#X restore 39 47 pd What_does_power_mean?; +#X text 18 80 [dbtopow] in PD performs the following equation to convert +the data: Note that incoming values less than 0 or greater than 870 +are considered overflow or underflow and are clipped/ignored.; +#X obj 148 222 dbtopow; +#X obj 21 226 max 0; +#X obj 21 246 min 870; +#X text 17 149 exp((2.302585092994 * 0.1) * (db_value - 100)) = Power +; +#X obj 21 269 expr exp((2.302585092994*0.1)*($f1-100)); +#X connect 1 0 6 0; +#X connect 1 0 7 0; +#X connect 6 0 3 0; +#X connect 7 0 8 0; +#X connect 8 0 10 0; +#X connect 10 0 2 0; +#X restore 154 330 pd understanding_dbtopow; +#N canvas 348 60 429 458 understanding_powtodb 0; +#N canvas 0 0 452 302 What_is_a_decibel? 0; +#X text 24 94 The difficulty in measuring the volume of an instrument +however is caused by 'distance'. For example \, at one metre away from +a door bell \, the amplitude might be 70 Decibels \, while at 50 metres +away the same door bell is just a fraction of that amplitude.; +#X text 25 33 DECIBELS are units by which we measure amplitude. A human +voice is approximately 70 Decibels - a snare drum is approximately +120 Decibels - the threshold of pain for the human ear is approximately +110 Decibels (poor drummers!); +#X text 23 174 Literally \, a Decibel is one-tenth of a Bel. A Bel +\, according to a medical dictionary is approximately the threshold +of the human ear at 1000 hz. I know that this seems a little vague +\, and perhaps this isn't the best way to explain it - we might as +well be measuring "fortnights" and "bunches" and "Alens"! Anyways...I'm +not an acoustician.; +#X restore 39 24 pd What_is_a_decibel?; +#X text 22 241 Example:; +#X floatatom 22 261 0 0 0; +#X floatatom 22 363 0 0 0; +#X floatatom 149 298 0 0 0; +#N canvas 0 0 442 244 What_does_power_mean? 0; +#X text 30 25 What does power mean? I really don't know? I can't determine +from my own research or from PD's documentation why or how this data +is used. All that I do know \, is that PD provides these objects for +a good reason -- I just don't know the reason.; +#X text 27 103 Having said that \, I would enjoy learning from somebody +who DOES know more about these objects and their usage. All that I +can offer is an explanation of the equation used to perform these conversions. +; +#X restore 39 47 pd What_does_power_mean?; +#X text 17 81 [powtodb] in PD performs the following equation to convert +the data: Note that incoming values less than 0 are considered underflow +and are clipped/ignored.; +#X text 17 149 (100 + ((10/2.302585092994) * log(POWER_value))) = Debibels +; +#X obj 149 278 powtodb; +#X obj 22 281 max 0; +#X obj 22 321 expr (100 + ((10/2.302585092994)*log($f1))); +#X obj 22 342 max 0; +#X connect 2 0 8 0; +#X connect 2 0 9 0; +#X connect 8 0 4 0; +#X connect 9 0 10 0; +#X connect 10 0 11 0; +#X connect 11 0 3 0; +#X restore 154 377 pd understanding_powtodb; +#X text 13 415 RELATED OBJECTS; +#X obj 14 434 dbtopow~; +#X obj 68 434 dbtorms~; +#X obj 123 434 rmstodb~; +#X obj 178 434 powtodb~; +#X obj 233 434 mtof~; +#X obj 270 434 ftom~; +#X obj 14 459 expr; +#X obj 46 459 expr~; +#N canvas 0 0 452 302 other_objects_from_related_libraries 0; +#X obj 26 39 db2v; +#X obj 65 38 f2note; +#X obj 115 39 b2db; +#X obj 150 40 t3_sig~; +#X obj 205 40 m2f~; +#X obj 249 41 tmtof; +#X text 18 96 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 17 145 The best places to find information about PD's libraries +is:; +#X text 14 167 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 15 183 or; +#X text 16 197 iem.kug.ac.at/pdb/; +#X restore 14 494 pd other_objects_from_related_libraries; +#X obj 90 459 rmstopow~; +#X obj 154 461 powtorms~; +#X obj 220 461 sig~; +#X obj 254 461 snapshot~; +#X text 14 550 This document was updated for PD version 0.35 test 29 +by Dave Sabine as part of a project called pddp proposed to build comprehensive +documentation for PD.; +#X connect 0 0 1 0; +#X connect 1 0 2 0; +#X connect 2 0 3 0; +#X connect 9 0 0 0; +#X connect 10 0 14 0; +#X connect 12 0 13 0; +#X connect 13 0 10 0; +#X connect 14 0 11 0; +#X connect 18 0 22 0; +#X connect 20 0 21 0; +#X connect 21 0 18 0; +#X connect 22 0 19 0; diff --git a/doc/pddp/help-adc~.pd b/doc/pddp/help-adc~.pd new file mode 100644 index 00000000..e281fc9a --- /dev/null +++ b/doc/pddp/help-adc~.pd @@ -0,0 +1,68 @@ +#N canvas 2 1 611 606 12; +#X obj 104 540 pddp; +#X obj 8 8 cnv 15 90 553 empty empty empty 20 12 0 14 -233017 -66577 +0; +#N canvas 85 2 593 609 More_Info 0; +#X text 16 13 MULTI-CHANNEL AUDIO; +#X text 32 40 All sound cards are capable of at least two channels +of audio. PD supports these two channels by default and uses your system's +generic audio drivers to communicate with your hardware. However \, +for faster input/output and for more than two channels of audio \, +PD incorporates the use of "PortAudio" which uses ASIO drivers to communicate +with your hardware. So \, to instruct PD to use more than two channels +of audio \, your command line should read like below:; +#X text 93 182 c:/pd/bin/pd.exe -pa -inchannels 8 -outchannels 8; +#X text 32 211 The "-pa" switch means "PortAudio". This switch is new +as of PD version 0.37 TEST 4 and replaces the old "-asio" switch.; +#X text 32 271 The "-inchannels" and "-outchannels" switches can be +summarized by using "-channels 8" because currently PortAudio requires +that the number of incoming and outgoing channels must be equal. This +may change in the PD's future...; +#X text 32 361 To further optimize PD's usage of your audio hardware +\, you can explore the following:; +#X text 42 402 - audiobuf; +#X text 43 420 - blocksize; +#X text 42 436 - audioindev; +#X text 42 454 - audiooutdev; +#X text 38 480 With the right hardware \, PD can manage audio input +and output with lower than 10 milliseconds of latency.; +#X restore 104 514 pd More_Info; +#N canvas 85 2 395 244 Related_Objects 0; +#X text 25 8 Native PD Objects; +#X text 25 92 Externals and other object libraries; +#X obj 45 46 dac~; +#X obj 98 46 switch~; +#X obj 171 46 block~; +#X restore 104 488 pd Related_Objects; +#X text 16 107 ARGUMENTS:; +#X text 32 188 OUTLETS:; +#X text 23 344 EXAMPLES:; +#X text 20 487 SEE ALSO:; +#X obj 33 20 adc~; +#X text 30 53 PURPOSE:; +#X text 108 18 - AUDIO INPUT: ANALOG/DIGITAL CONVERTER SIGNAL; +#X text 152 541 - Dave Sabine \, May 6 \, 2003; +#X text 104 53 [adc~] is an acronym meaning "Analog/Digital Converter +Signal" and is PD's interface to access the audio information arriving +at your soundcard(s).; +#X text 106 106 The object defaults to 2 incoming audio channels (usually +a left and right stereo pair). Any number of arguments (integers) can +be used to define multiple input channels - each integer corresponds +to an input channel on your audio hardware.; +#X text 107 188 Signal: the number of outlets correspond with the number +of arguments - each outlet represents an input channel on your audio +hardware which corresponds to the argument you provide. If no arguments +are provided \, then there are two outlets which represent audio channels +1 and 2 on your computers sound card.; +#X text 107 290 The information at each outlet is an audio signal (i.e. +the object operates at 'audio-rate') and therefore must be connected +to an audio inlet on a related object.; +#X obj 109 346 adc~; +#X text 153 346 default stereo signals: same as; +#X obj 411 348 adc~ 1 2; +#X obj 109 373 adc~ 5; +#X text 167 374 a mono signal from channel 5; +#X obj 109 404 adc~ 1 3 8 6 11 15 19 22 23 24 36; +#X text 383 405 11 channels of audio; +#X obj 109 434 adc~ 1 2 3 4 5 6 7 8; +#X text 280 435 all channels on an 8-channel device; diff --git a/doc/pddp/help-adc~_dac~.pd b/doc/pddp/help-adc~_dac~.pd new file mode 100644 index 00000000..33a21a23 --- /dev/null +++ b/doc/pddp/help-adc~_dac~.pd @@ -0,0 +1,108 @@ +#N canvas 3 0 619 592 12; +#X obj 104 540 pddp; +#X obj 8 8 cnv 15 90 553 empty empty empty 20 12 0 14 -233017 -66577 +0; +#N canvas 129 0 415 237 More_Info 0; +#N canvas 131 29 532 435 sample_rate 0; +#X text 12 24 SAMPLE RATE; +#X text 29 46 [adc~] and [dac~] always operate at the sample rate that +is specified in PD's command line. By default \, the sample rate is +44100 hz. But PD operates any sample rate supported by standard audio +hardware. Sample rates cannot be changed at run-time in PD \, but must +be stated in the command line when PD is instantiated. As well \, two +or more instances of PD running simoultaneously can each be using different +sample rates! Having said that \, PD can easily upsample or downsample +by using the [block~] object. Here are some example of the common sample +rates:; +#X text 85 232 c:/pd/bin/pd.exe -r 11025; +#X text 85 262 c:/pd/bin/pd.exe -r 22050; +#X text 86 329 c:/pd/bin/pd.exe -r 88200; +#X text 85 217 c:/pd/bin/pd.exe -r 8000; +#X text 85 247 c:/pd/bin/pd.exe -r 16000; +#X text 86 278 c:/pd/bin/pd.exe -r 32000; +#X text 86 294 c:/pd/bin/pd.exe -r 44100 CD Quality; +#X text 86 311 c:/pd/bin/pd.exe -r 48000 DAT Quality; +#X text 87 366 c:/pd/bin/pd.exe -r 192000 DVD-Audio Quality; +#X text 86 347 c:/pd/bin/pd.exe -r 96000 DVD-Video/Audio Quality; +#X restore 40 75 pd sample_rate; +#N canvas 131 31 564 558 multi-channel_audio 0; +#X text 16 13 MULTI-CHANNEL AUDIO; +#X text 32 40 All sound cards are capable of at least two channels +of audio. PD supports these two channels by default and uses your system's +generic audio drivers to communicate with your hardware. However \, +for faster input/output and for more than two channels of audio \, +PD incorporates the use of "PortAudio" which uses ASIO drivers to communicate +with your hardware. So \, to instruct PD to use more than two channels +of audio \, your command line should read like below:; +#X text 93 182 c:/pd/bin/pd.exe -pa -inchannels 8 -outchannels 8; +#X text 32 211 The "-pa" switch means "PortAudio". This switch is new +as of PD version 0.37 TEST 4 and replaces the old "-asio" switch.; +#X text 32 271 The "-inchannels" and "-outchannels" switches can be +summarized by using "-channels 8" because currently PortAudio requires +that the number of incoming and outgoing channels must be equal. This +may change in the PD's future...; +#X text 32 361 To further optimize PD's usage of your audio hardware +\, you can explore the following:; +#X text 42 402 - audiobuf; +#X text 43 420 - blocksize; +#X text 42 436 - audioindev; +#X text 42 454 - audiooutdev; +#X text 38 480 With the right hardware \, PD can manage audio input +and output with lower than 10 milliseconds of latency.; +#X restore 40 112 pd multi-channel_audio; +#N canvas 132 30 528 211 defeating_audio_computation 0; +#X text 21 15 -NODAC and -NOADC; +#X text 26 37 There may be cases when you do not want PD to send or +receive audio signal with your soundcard. You can manually disable +the [dac~] and [adc~] objects separately using the "-nodac" and "-noadc" +switch \, or disable both using the "-nosound" switch.; +#X restore 41 152 pd defeating_audio_computation; +#X restore 104 514 pd More_Info; +#N canvas 85 2 399 248 Related_Objects 0; +#X text 25 8 Native PD Objects; +#X text 25 118 Externals and other object libraries; +#X obj 57 35 bilge; +#X text 35 143 [shoutcast~]; +#X text 35 166 [oggcast~]; +#X obj 115 35 send~; +#X obj 169 35 receive~; +#X obj 58 66 throw~; +#X obj 121 66 catch~; +#X obj 185 66 block~; +#X obj 249 66 switch~; +#X restore 104 488 pd Related_Objects; +#X text 14 84 ARGUMENTS:; +#X text 22 219 EXAMPLES:; +#X text 21 463 SEE ALSO:; +#X obj 12 19 adc~; +#X obj 61 19 dac~; +#X text 108 18 - AUDIO INPUT/OUTPUT; +#X text 30 47 PURPOSE:; +#X text 104 47 [adc~] and [dac~] provide real-time audio input and +output for PD \, respectively \, whether analog or digital.; +#X text 152 541 - Dave Sabine \, May 5 \, 2003; +#X text 104 83 Both of these objects accept arguments (numbers) which +indicate which audio channels are to be used by PD. By default \, these +objects are stereo and communicate on audio channels 1 and 2 (left +and right respectively) but by using arguments \, other channel numbers +can be specified. These objects can communicate with hundreds of audio +channels \, but you are likely limited by your audio hardware to 2 +\, 4 \, 6 \, 8 \, 12 \, 16 \, 32 \, 64 \, etc.; +#X obj 114 222 adc~; +#X text 162 222 incoming stereo signals; +#X obj 114 251 dac~; +#X text 162 252 outgoing stereo signals; +#X obj 114 280 adc~ 1 2 3 4 5 6 7 8; +#X text 290 281 eight incoming audio signals; +#X text 210 314 three outgoing signals on channels 1 \, 5 \, and 6 +; +#X obj 115 314 dac~ 1 5 6; +#X text 107 345 The actual number of PD inputs and outputs are set +on PD's command line. You can open patches that want to use more channels +\, but channel numbers that out of range will be dropped by [dac~] +or appears as zero by [adc~].; +#X text 14 344 IMPORTANT:; +#X text 108 419 Also \, these objects do not operate unless PD is instructed +to "Compute Audio".; +#X obj 104 464 help-adc~; +#X obj 190 464 help-dac~; diff --git a/doc/pddp/help-bang.pd b/doc/pddp/help-bang.pd new file mode 100644 index 00000000..24787bd1 --- /dev/null +++ b/doc/pddp/help-bang.pd @@ -0,0 +1,143 @@ +#N canvas 12 2 916 656 10; +#X obj 502 191 print; +#X obj 22 14 bang; +#X msg 514 133 walk the cat; +#X msg 501 112 45; +#X obj 502 166 bang; +#X text 110 13 - SEND "BANG" MESSAGE; +#X obj 76 14 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 22 38 The bang object is one of the basic building blocks of +PD and are normally used to activate events. The bang object can be +created in two different ways.; +#X obj 45 83 bang; +#X text 22 82 1; +#X text 21 141 2; +#X obj 45 142 bng 15 250 50 0 empty empty empty 18 7 0 8 -262144 -1 +-1; +#X text 45 107 This version uses minimal CPU but serves essentially +the same purpose as the GUI version.; +#X text 43 286 1 Size; +#X obj 122 289 bng 8 250 50 0 empty empty 8 10 4 0 8 -262144 -1 -1 +; +#X obj 147 282 bng 15 250 50 0 empty empty 15 17 9 0 8 -262144 -1 -1 +; +#X obj 182 272 bng 25 250 50 0 empty empty 25 27 20 0 8 -262144 -1 +-1; +#X text 69 304 Default size is 15 pixels. The minimum size is 8 and +it does not have a maximum size.; +#X text 41 465 3 Hold; +#X obj 111 465 bng 15 50 10 0 empty empty 50 17 8 0 8 -262144 -1 -1 +; +#X obj 146 465 bng 15 750 50 0 empty empty 750 17 8 0 8 -262144 -1 +-1; +#X text 41 538 4 Receive Symbol/Send Symbol; +#X text 67 553 This object can act as its own send or receive object. +; +#X obj 69 575 bng 15 250 50 0 link_this_bang empty This_one_sends_a_bang +17 8 128 8 -262144 -1 -1; +#X obj 69 596 bng 15 250 50 0 empty link_this_bang This_one_receives_it. +17 8 64 8 -262144 -1 -1; +#X text 280 567 Here is the alternative method.; +#X text 44 644 5 GUI Options; +#X obj 506 368 bng 8 250 50 0 empty empty empty 0 -6 0 12 -262144 -1 +-1; +#X msg 679 359 label Name_that_bang; +#X msg 692 383 label Rename_that_bang; +#X msg 719 405 size 8; +#X text 67 666 The other properties are 'name' \, 'x/y offset' \, 'font +size' \, and colours (for the background \, front \, and labels [name]) +; +#X obj 471 19 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 471 659 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 495 55 WHAT CAN IT DO?; +#X text 495 67 The bang object outputs "bang" when it receives something +in its inlet or its 'internal' receive symbol (GUI version only).; +#X text 547 190 The output window will print "bang" to demonstrate. +; +#X obj 647 162 print; +#X msg 647 116 walk the cat; +#X obj 647 141 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 502 215 It is important to note that "bang" is not boolean. +It's neither a zero or a one \; it's not true or false \; it's just +"bang". For a boolean object \, you should check out the toggle.; +#X obj 502 487 loadbang; +#X obj 643 487 tgl 15 0 empty empty Toggle 0 -6 0 8 -262144 -1 -1 0 +1; +#X obj 557 487 trigger; +#X obj 606 487 bang~; +#X text 502 290 OTHER HELPFUL INFO; +#X msg 735 427 size 25; +#X text 502 312 The label and size properties of the bng object (from +IEM library) can be updated dynamically by sending messages to its +inlet.; +#X text 512 461 RELATED OBJECTS; +#X text 44 165 This version uses a little more CPU than its cousin +because it lights-up when it receives a message or is clicked on and +can be coloured \, resized \, or renamed. It is sometimes 'friendlier' +as well because it can act as its own send and receive object (see +properties...). This object can be put in a PD patch either by keyboard +shortcut: ALT+B or by creating and object (CTRL+1) called "bng".; +#X text 66 482 The default hold is 250 milliseconds. The hold value +controls the length of time that the bng object stays "lit". Note that +bng sends its message immediately regardless of the hold value.; +#X obj 261 621 s linked_bngs; +#X obj 370 583 r linked_bngs; +#X text 40 334 2 Interrupt (milliseconds); +#X text 66 348 If the bng object is "lit" and holding (see "hold" below) +\, then receives another message before the hold time has passed \, +the bng will quickly flash again for the duration you set in this interrupt +property.; +#X obj 42 421 bng 15 1000 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 65 405 This bng will hold for 1000 milliseconds \, but interrupt +for 50 milliseconds if it gets a second message during its "hold". +Click it once...wait. Then click it multiple times rather quickly to +see the effect.; +#X obj 261 603 bang; +#X obj 370 602 bang; +#X msg 261 584 send a message; +#X obj 370 620 print; +#X text 69 143 a.k.a. "bng"; +#X text 43 264 PROPERTIES OF BNG; +#X text 497 548 This document was updated for PD version 0.35 test +24 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#N canvas 4 24 432 275 related_objects_from_other_libraries 0; +#X obj 266 48 oneshot; +#X obj 259 28 toddle; +#X obj 18 48 render_trigger; +#X obj 18 28 metroplus; +#X obj 78 28 exciter; +#X obj 127 28 bangfilter1+2; +#X obj 211 28 counter; +#X obj 108 48 countund; +#X obj 163 48 kalashnikov; +#X obj 236 48 init; +#X text 18 86 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 17 135 The best places to find information about PD's libraries +is:; +#X text 14 157 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 15 173 or; +#X text 16 187 iem.kug.ac.at/pdb/; +#X restore 501 513 pd related_objects_from_other_libraries; +#X connect 2 0 4 0; +#X connect 3 0 4 0; +#X connect 4 0 0 0; +#X connect 28 0 27 0; +#X connect 29 0 27 0; +#X connect 30 0 27 0; +#X connect 32 0 33 0; +#X connect 38 0 39 0; +#X connect 39 0 37 0; +#X connect 46 0 27 0; +#X connect 52 0 58 0; +#X connect 57 0 51 0; +#X connect 58 0 60 0; +#X connect 59 0 57 0; diff --git a/doc/pddp/help-bendin.pd b/doc/pddp/help-bendin.pd new file mode 100644 index 00000000..e14aa01d --- /dev/null +++ b/doc/pddp/help-bendin.pd @@ -0,0 +1,66 @@ +#N canvas 244 81 492 554 10; +#X text 118 123 outlets:; +#X floatatom 16 149 5 0 0; +#X floatatom 59 149 5 0 0; +#N canvas 240 135 476 472 other_midi_objects 0; +#X obj 7 29 ctlin; +#X obj 49 29 pgmin; +#X obj 92 28 bendin; +#X obj 143 27 touchin; +#X obj 204 27 polytouchin; +#X obj 289 27 midiin; +#X obj 340 26 sysexin; +#X obj 6 85 noteout; +#X obj 63 84 ctlout; +#X obj 160 84 bendout; +#X obj 217 83 touchout; +#X obj 281 82 polytouchout; +#X obj 370 82 midiout; +#X obj 113 84 pgmout; +#X obj 11 153 makenote; +#X text 10 194 MIDI notes deconstruction:; +#X text 8 128 MIDI note construction:; +#X text 8 58 MIDI output:; +#X text 8 2 MIDI input:; +#X obj 15 226 stripnote; +#X text 11 266 Additional useful objects for MIDI processing (Maxlib +by Olaf Matthes); +#X obj 148 297 chord; +#X obj 109 296 borax; +#X obj 54 296 score o; +#X obj 13 296 pitch; +#X text 15 336 Also \, from cyclone (alpha) by Krzysztof Czaja:; +#X obj 16 359 midiformat; +#X obj 172 359 midiflush; +#X obj 98 359 midiparse; +#X text 15 386 and xeq \, from the same developer; +#X obj 16 411 xeq; +#X text 41 402 an experimental MIDI sequencer; +#X restore 20 401 pd other_midi_objects; +#X text 18 346 related object; +#X obj 283 420 midi-basics; +#X text 18 421 for an explanation of MIDI usage in PD see:; +#X obj 33 18 bendin; +#X text 119 103 inlets : none (reads directly from the MIDI port); +#X obj 23 107 bendin; +#X text 9 49 The [bendin] object reads incoming pitch bend values and +reports them. If started with no arguments it reports the channel number +through the right outlet.; +#X text 14 192 Arguments: the MIDI channel number from which to read. +If the argument is present \, the [bendin] object does not show the +second (right) outlet:; +#X obj 25 256 bendin 2; +#X floatatom 25 278 5 0 0; +#X obj 21 361 bendout; +#X text 76 279 <-- pitch bend values on channel 2; +#X text 16 312 Output (int) is a 14-bit pitchbend value; +#X text 130 142 left: pitchbend value; +#X text 129 159 right: MIDI channel number (if no argument); +#X text 81 19 - read incoming pitch bend values.; +#X text 19 482 This document was updated for PD version 0.35 by Michal +Seta as part of a project called pddp proposed by Krzysztof Czaja \, +managed and edited by Dave Sabine \, to build comprehensive documentation +for PD.; +#X connect 9 0 1 0; +#X connect 9 1 2 0; +#X connect 12 0 13 0; diff --git a/doc/pddp/help-bendout.pd b/doc/pddp/help-bendout.pd new file mode 100644 index 00000000..f25791f3 --- /dev/null +++ b/doc/pddp/help-bendout.pd @@ -0,0 +1,67 @@ +#N canvas 249 47 492 554 10; +#X floatatom 17 124 5 0 0; +#X floatatom 61 141 5 0 0; +#N canvas 240 135 476 472 other_midi_objects 0; +#X obj 55 31 ctlin; +#X obj 97 31 pgmin; +#X obj 140 30 bendin; +#X obj 191 29 touchin; +#X obj 252 29 polytouchin; +#X obj 337 29 midiin; +#X obj 388 28 sysexin; +#X obj 6 85 noteout; +#X obj 63 84 ctlout; +#X obj 161 85 touchout; +#X obj 225 84 polytouchout; +#X obj 314 84 midiout; +#X obj 113 84 pgmout; +#X obj 11 153 makenote; +#X text 10 194 MIDI notes deconstruction:; +#X text 8 128 MIDI note construction:; +#X text 8 58 MIDI output:; +#X text 8 2 MIDI input:; +#X obj 15 226 stripnote; +#X text 11 266 Additional useful objects for MIDI processing (Maxlib +by Olaf Matthes); +#X obj 148 297 chord; +#X obj 109 296 borax; +#X obj 54 296 score o; +#X obj 13 296 pitch; +#X text 15 336 Also \, from cyclone (alpha) by Krzysztof Czaja:; +#X obj 16 359 midiformat; +#X obj 172 359 midiflush; +#X obj 98 359 midiparse; +#X text 15 386 and xeq \, from the same developer; +#X obj 16 411 xeq; +#X text 41 402 an experimental MIDI sequencer; +#X obj 8 31 midiin; +#X restore 20 392 pd other_midi_objects; +#X text 18 337 related object; +#X obj 282 412 midi-basics; +#X text 18 412 for an explanation of MIDI usage in PD see:; +#X floatatom 20 266 5 0 0; +#X text 111 263 <-- pitch bend values on channel 2; +#X obj 39 21 bendout; +#X obj 17 165 bendout; +#X text 120 114 inlets:; +#X text 119 165 outlets : none (writes directly to the MIDI port); +#X text 128 132 left: 14-bit pitchbend value; +#X text 127 148 right: MIDI channel number; +#X text 14 198 Arguments: the MIDI channel number to which to write +to. If no argument is given [bendout] defaults to channel 1 The channel +can be then chaned byy sending an int to the right inlet:; +#X obj 20 284 bendout 2; +#X text 16 314 Output: the output is direct to the MIDI port.; +#X obj 21 352 bendin; +#X text 12 51 The [bendout] object takes a pitchbend value (0-127) +and formats it into a pitchbend MIDI message and sends out the MIDI +port on the appropriate channel. If no argument is given it defaults +to channel 1; +#X text 87 22 - send pitchbend value to the MIDI port; +#X text 18 482 This document was updated for PD version 0.35 by Michal +Seta as part of a project called pddp proposed by Krzysztof Czaja \, +managed and edited by Dave Sabine \, to build comprehensive documentation +for PD.; +#X connect 0 0 9 0; +#X connect 1 0 9 1; +#X connect 6 0 15 0; diff --git a/doc/pddp/help-bng.pd b/doc/pddp/help-bng.pd new file mode 100644 index 00000000..e5ddf65f --- /dev/null +++ b/doc/pddp/help-bng.pd @@ -0,0 +1,269 @@ +#N canvas 60 138 517 433 10; +#X obj 1 1 cnv 8 100 60 empty empty bng 20 20 1 18 -262144 -1109 0 +; +#X text 10 288 (c) musil@iem.kug.ac.at; +#X text 52 301 IEM KUG; +#X text 118 61 click properties to; +#X text 106 72 modify geometry \, colors \, etc.; +#X obj 64 257 print; +#N canvas 598 330 290 225 once 0; +#X msg 38 73 1; +#X obj 38 47 t b b; +#X obj 68 124 sel 0; +#X obj 68 103 f 0; +#X obj 38 24 inlet; +#X obj 68 154 outlet; +#X connect 0 0 3 1; +#X connect 1 0 0 0; +#X connect 1 1 3 0; +#X connect 2 0 5 0; +#X connect 3 0 2 0; +#X connect 4 0 1 0; +#X restore 64 234 pd once; +#X obj 36 258 bng 15 250 50 0 empty empty empty 8 -8 0 10 -262144 -1 +-1; +#X obj 3 130 bng 15 250 50 0 empty empty empty 8 -8 0 10 -262144 -1 +-1; +#X obj 36 173 bng 50 950 50 1 foo5_snd foo5_rcv big-bang 63 2 192 12 +-262131 -260818 -143491; +#X msg 36 53 33; +#X msg 50 75 -3.14; +#X msg 73 117 11 22 33.33; +#X msg 63 95 open xxx; +#X msg 96 142 funny; +#X text 101 11 gui-bang:; +#X obj 202 135 s foo5_rcv; +#X obj 202 155 r foo5_snd; +#X obj 202 115 bng 15 250 50 0 empty empty empty 8 -8 0 10 -262144 +-1 -1; +#X obj 202 175 bng 15 250 50 0 empty empty empty 8 -8 0 10 -262144 +-1 -1; +#X msg 4 53 0; +#X text 125 205 UP- \, DOWN- \, LEFT- or RIGHT-key; +#X text 124 216 for moving selected gui-objects; +#N canvas 425 170 699 530 edit 0; +#X obj 39 197 f; +#X msg 17 176 bang; +#X floatatom 55 175 3 63 88; +#X floatatom 90 197 3 0 37; +#X obj 39 220 pack 0 0; +#X text 117 197 y-label; +#X text 83 175 x-label; +#X floatatom 259 143 3 8 75; +#X text 286 143 size; +#X obj 279 236 f; +#X msg 257 215 bang; +#X floatatom 295 214 3 -10 10; +#X floatatom 330 236 3 -10 10; +#X obj 279 259 pack 0 0; +#X obj 304 348 f; +#X msg 282 327 bang; +#X floatatom 320 326 3 20 90; +#X floatatom 355 348 3 150 200; +#X obj 304 371 pack 0 0; +#X text 323 214 x-delta; +#X text 357 236 y-delta; +#X text 348 326 x-position; +#X text 382 348 y-position; +#X obj 59 312 f; +#X msg 37 291 bang; +#X floatatom 75 290 3 0 2; +#X floatatom 110 312 3 4 36; +#X obj 59 335 pack 0 0; +#X text 103 290 font; +#X text 139 312 height; +#X msg 36 399 \; foo5_rcv label blabla; +#X msg 59 360 \; foo5_rcv label_font \$1 \$2; +#X msg 39 245 \; foo5_rcv label_pos \$1 \$2; +#X msg 47 135 \; foo5_rcv color \$1 \$2 \$3; +#X msg 259 172 \; foo5_rcv size \$1; +#X msg 279 284 \; foo5_rcv delta \$1 \$2; +#X msg 304 396 \; foo5_rcv pos \$1 \$2; +#X msg 483 133 \; foo5_rcv receive foo5a_rcv; +#X msg 482 171 \; foo5a_rcv receive foo5_rcv; +#X msg 483 50 \; foo5_rcv send foo5a_snd; +#X msg 483 88 \; foo5_rcv send foo5_snd; +#X text 526 349 no init; +#X msg 505 368 \; foo5_rcv init 0; +#X msg 512 435 \; foo5_rcv init 1; +#X obj 493 260 f; +#X msg 471 239 bang; +#X floatatom 509 238 4 10 100; +#X floatatom 544 261 5 100 3000; +#X obj 493 283 pack 0 0; +#X msg 493 308 \; foo5_rcv flashtime \$1 \$2; +#X text 548 237 interrupt-time; +#X text 585 262 hold-time; +#X msg 36 435 \; foo5_rcv label big-bang; +#X text 502 417 init bang on loadbang; +#X text 519 221 flash-time:; +#X obj 47 114 pack 0 0 0; +#X obj 47 86 f; +#X msg 24 38 bang; +#X floatatom 63 36 3 0 29; +#X floatatom 79 56 3 0 29; +#X floatatom 112 72 3 0 29; +#X text 91 36 background; +#X text 106 56 front-color; +#X text 140 73 label-color; +#X msg 285 35 back; +#X msg 285 55 front; +#X msg 285 75 label; +#X msg 247 35 bang; +#N canvas 15 207 606 448 RGB_____________ 0; +#X obj 97 56 inlet; +#X obj 262 53 inlet; +#X obj 339 55 inlet; +#X obj 405 56 inlet; +#X obj 97 270 bang; +#X msg 77 295 0; +#X msg 104 295 1; +#X obj 146 268 bang; +#X msg 132 295 0; +#X msg 160 295 1; +#X obj 196 269 bang; +#X msg 187 295 0; +#X msg 214 295 1; +#X obj 265 313 spigot; +#X obj 312 313 spigot; +#X obj 359 313 spigot; +#X obj 249 385 outlet; +#X text 93 33 select; +#X text 267 28 red; +#X text 337 30 green; +#X text 409 30 blue; +#X obj 405 102 t b f; +#X obj 339 160 +; +#X obj 339 185 t b f; +#X obj 339 216 +; +#X obj 296 385 outlet; +#X obj 343 385 outlet; +#X obj 28 180 loadbang; +#X obj 97 135 route back front label bang; +#X obj 343 362 f; +#X obj 296 361 f; +#X obj 249 361 f; +#X obj 262 79 * -65536; +#X obj 339 80 * -256; +#X obj 405 80 * -1; +#X obj 339 247 - 1; +#X obj 235 168 t b b b b; +#X connect 0 0 28 0; +#X connect 1 0 32 0; +#X connect 2 0 33 0; +#X connect 3 0 34 0; +#X connect 4 0 5 0; +#X connect 4 0 6 0; +#X connect 5 0 14 1; +#X connect 5 0 15 1; +#X connect 6 0 13 1; +#X connect 7 0 8 0; +#X connect 7 0 9 0; +#X connect 8 0 13 1; +#X connect 8 0 15 1; +#X connect 9 0 14 1; +#X connect 10 0 11 0; +#X connect 10 0 12 0; +#X connect 11 0 13 1; +#X connect 11 0 14 1; +#X connect 12 0 15 1; +#X connect 13 0 31 1; +#X connect 14 0 30 1; +#X connect 15 0 29 1; +#X connect 21 0 22 0; +#X connect 21 1 22 1; +#X connect 22 0 23 0; +#X connect 23 0 24 0; +#X connect 23 1 24 1; +#X connect 24 0 35 0; +#X connect 27 0 6 0; +#X connect 28 0 4 0; +#X connect 28 1 7 0; +#X connect 28 2 10 0; +#X connect 28 3 36 0; +#X connect 29 0 26 0; +#X connect 30 0 25 0; +#X connect 31 0 16 0; +#X connect 32 0 24 0; +#X connect 33 0 22 0; +#X connect 34 0 21 0; +#X connect 35 0 15 0; +#X connect 35 0 14 0; +#X connect 35 0 13 0; +#X connect 36 0 31 0; +#X connect 36 1 30 0; +#X connect 36 2 29 0; +#X connect 36 3 35 0; +#X restore 285 96 pd RGB_____________; +#X floatatom 327 65 3 0 255; +#X floatatom 370 65 3 0 255; +#X floatatom 413 66 3 0 255; +#X text 34 10 preset-colors; +#X text 296 7 RGB-colors; +#X text 327 47 red; +#X text 363 46 green; +#X text 411 46 blue; +#X connect 0 0 4 0; +#X connect 1 0 0 0; +#X connect 2 0 0 1; +#X connect 3 0 4 1; +#X connect 4 0 32 0; +#X connect 7 0 34 0; +#X connect 9 0 13 0; +#X connect 10 0 9 0; +#X connect 11 0 9 1; +#X connect 12 0 13 1; +#X connect 13 0 35 0; +#X connect 14 0 18 0; +#X connect 15 0 14 0; +#X connect 16 0 14 1; +#X connect 17 0 18 1; +#X connect 18 0 36 0; +#X connect 23 0 27 0; +#X connect 24 0 23 0; +#X connect 25 0 23 1; +#X connect 26 0 27 1; +#X connect 27 0 31 0; +#X connect 44 0 48 0; +#X connect 45 0 44 0; +#X connect 46 0 44 1; +#X connect 47 0 48 1; +#X connect 48 0 49 0; +#X connect 55 0 33 0; +#X connect 56 0 55 0; +#X connect 57 0 56 0; +#X connect 58 0 56 1; +#X connect 59 0 55 1; +#X connect 60 0 55 2; +#X connect 64 0 68 0; +#X connect 65 0 68 0; +#X connect 66 0 68 0; +#X connect 67 0 68 0; +#X connect 68 0 55 0; +#X connect 68 1 55 1; +#X connect 68 2 55 2; +#X connect 69 0 68 1; +#X connect 70 0 68 2; +#X connect 71 0 68 3; +#X restore 297 144 pd edit; +#X obj 248 34 bng 15 250 50 0 aaa aaa empty 20 8 192 8 -262144 -1 -1 +; +#X text 27 313 graz \, austria 2002; +#X obj 180 11 x_all_guis aaa bbb ccc ddd eee fff ggg hhh iii; +#X text 366 35 SEE ALSO:; +#X obj 429 34 bang; +#X text 22 341 This document was updated for PD version 0.35 test 24 +by Dave Sabine as part of a project called pddp proposed to build comprehensive +documentation for PD.; +#X connect 6 0 5 0; +#X connect 8 0 9 0; +#X connect 9 0 7 0; +#X connect 9 0 5 0; +#X connect 10 0 9 0; +#X connect 11 0 9 0; +#X connect 12 0 9 0; +#X connect 13 0 9 0; +#X connect 14 0 9 0; +#X connect 17 0 19 0; +#X connect 18 0 16 0; +#X connect 20 0 9 0; diff --git a/doc/pddp/help-change.pd b/doc/pddp/help-change.pd new file mode 100644 index 00000000..3f77da07 --- /dev/null +++ b/doc/pddp/help-change.pd @@ -0,0 +1,52 @@ +#N canvas 33 5 471 644 10; +#X floatatom 23 489 0 0 0; +#X floatatom 23 400 0 0 0; +#X floatatom 61 416 0 0 0; +#X obj 66 15 change; +#X text 114 16 - ELIMINATE REDUNDANCY IN A NUMBER STEAM; +#X msg 61 438 set \$1; +#X text 106 438 set the value; +#X text 60 400 if different from current value \, output and set; +#X obj 23 510 print; +#X msg 16 81 1; +#X msg 44 81 1; +#X msg 73 81 1; +#X msg 106 80 0; +#X text 14 65 Click from left to right...; +#X obj 16 112 change; +#X obj 16 133 print; +#X text 51 133 Watch terminal window.; +#X text 12 42 The change object outputs its input only when it changes. +; +#X text 15 160 [change] will accept a float as a creation argument. +That creation argument will define the inital value.; +#X obj 19 225 change 6.5; +#X obj 19 248 print; +#X msg 19 196 6.5; +#X msg 49 196 5.5; +#X msg 191 285 bang; +#X text 20 318 It's important to note that when [change] receives a +number in its inlet \, that number is outputted (if its different than +the currently stored value) and then stored.; +#X obj 23 467 change; +#X text 19 365 The "set" method can be used to store a number in the +object without outputting that value.; +#X text 22 585 This document was updated for PD version 0.35 test 26 +by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X text 17 269 Sending a "bang" message to the inlet will force [change] +to output its current value.; +#X connect 0 0 8 0; +#X connect 1 0 25 0; +#X connect 2 0 5 0; +#X connect 5 0 25 0; +#X connect 9 0 14 0; +#X connect 10 0 14 0; +#X connect 11 0 14 0; +#X connect 12 0 14 0; +#X connect 14 0 15 0; +#X connect 19 0 20 0; +#X connect 21 0 19 0; +#X connect 22 0 19 0; +#X connect 23 0 19 0; +#X connect 25 0 0 0; diff --git a/doc/pddp/help-clip.pd b/doc/pddp/help-clip.pd new file mode 100644 index 00000000..04f8ddb5 --- /dev/null +++ b/doc/pddp/help-clip.pd @@ -0,0 +1,130 @@ +#N canvas 3 0 630 628 12; +#X obj 114 560 pddp; +#X obj 8 3 cnv 15 90 578 empty empty empty 20 12 0 14 -233017 -66577 +0; +#X text 38 36 INLETS:; +#X text 38 51 - LEFT:; +#X text 32 230 - RIGHT:; +#X text 29 346 OUTLETS:; +#X text 13 281 ARGUMENTS:; +#X text 20 412 EXAMPLES:; +#X text 20 508 SEE ALSO:; +#N canvas 58 0 411 260 Related_Objects 0; +#X text 25 11 Native PD Objects; +#X text 23 92 Externals and other object libraries; +#X obj 45 54 int; +#X obj 85 53 f; +#X obj 123 53 min; +#X obj 166 53 max; +#X obj 206 53 clip~; +#X obj 260 53 min~; +#X obj 308 53 max~; +#X text 44 125 - none that I am aware of; +#X restore 114 508 pd Related_Objects; +#N canvas 57 0 639 620 More_Info 0; +#X text 26 174 THE MYSTERIOUS RIGHT OUTLET; +#X obj 158 252 clip; +#X obj 82 240 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 130 203 5 0 0 0 - - -; +#X symbolatom 195 204 10 0 0 0 - - -; +#X msg 209 227 list dave peter john; +#X msg 49 200 message; +#X floatatom 199 281 5 0 0 0 - - -; +#X obj 258 278 print; +#X obj 174 283 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 313 280 no response to any message or atom.; +#X text 30 347 LOW AND HIGH VALUES; +#X text 304 34 Consider the following:; +#X floatatom 101 66 5 0 0 0 - - -; +#X floatatom 83 147 5 0 0 0 - - -; +#X obj 83 121 min 50; +#X obj 83 95 max -50; +#X text 170 106 same as; +#X obj 271 104 clip -50 50; +#X floatatom 271 133 5 0 0 0 - - -; +#X text 43 18 [clip] is a tool which combines the functionality of +[min] and [max] into a single object.; +#X text 46 368 [clip] always assumes that the first argument (second +inlet) is the low extreme of the range and the second argument (third +inlet) is the high extreme. However \, strange behaviour should be +expected if you mix these arguments up.; +#X obj 54 491 clip -50 50; +#X obj 180 485 clip 72 -104; +#X floatatom 54 458 5 0 0 0 - - -; +#X floatatom 54 520 5 0 0 0 - - -; +#X floatatom 180 517 5 0 0 0 - - -; +#X text 50 306 I assume it is there for a reason...but I don't know +that reason. It might exist for compatiblity with MAX?; +#X text 185 444 Numbers below 72 are clipped to 72; +#X text 185 464 Numbers above -104 are clipped to -104; +#X text 172 565 This could be used effectively to toggle between two +numbers.; +#X floatatom 391 543 5 0 0 0 - - -; +#X obj 360 520 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 +1; +#X obj 392 512 clip 1 -1024; +#X connect 1 1 7 0; +#X connect 1 1 8 0; +#X connect 1 1 9 0; +#X connect 2 0 1 0; +#X connect 3 0 1 0; +#X connect 4 0 1 0; +#X connect 5 0 1 0; +#X connect 6 0 1 0; +#X connect 13 0 16 0; +#X connect 13 0 18 0; +#X connect 15 0 14 0; +#X connect 16 0 15 0; +#X connect 18 0 19 0; +#X connect 22 0 25 0; +#X connect 23 0 26 0; +#X connect 24 0 22 0; +#X connect 24 0 23 0; +#X connect 32 0 33 0; +#X connect 33 0 31 0; +#X restore 114 534 pd More_Info; +#X obj 57 11 clip; +#X text 105 51 Float - A float at the left inlet will be clipped to +the low and high values stored in the object.; +#X text 105 82 List - A list at the left inlet will be truncated to +include only the first three elements. The first element in the list +is the number which will be clipped. The second element will update +the value stored at the second inlet. The third element will update +the value stored at the third inlet.; +#X text 25 180 - CENTER:; +#X text 105 180 Float - A float at the second inlet is stored for later +use. It will be used as either the low or high value at which to clip +incoming floats at that left inlet.; +#X text 105 231 Float - A float at the third inlet is stored for later +use. It will be used as either the low or high value at which to clip +incoming floats at that left inlet.; +#X text 104 281 Two - [float] accepts two floats as creation arguments +which initializes the first values to be stored in the object and duplicate +the functions of the second and third inlet.; +#X text 102 346 One - outputs a float which is limited to a range within +the high and low values of the second and third inlet. (The second +outlet has no apparent purpose other than cross-compatibility with +MAX.); +#X text 108 12 - FORCE A NUMBER INTO A RANGE; +#X obj 122 448 clip -50 50; +#X floatatom 122 475 5 0 0 0 - - -; +#X floatatom 122 424 5 0 0 0 - - -; +#X text 181 425 creation arguments; +#X obj 411 486 clip; +#X floatatom 404 458 5 0 0 0 - - -; +#X floatatom 460 457 5 0 0 0 - - -; +#X floatatom 520 457 5 0 0 0 - - -; +#X floatatom 411 512 5 0 0 0 - - -; +#X text 464 488 no arguments; +#X text 494 425 list; +#X text 158 561 - Dave Sabine \, April 25 \, 2003; +#X msg 383 425 42 100 500; +#X connect 20 0 21 0; +#X connect 22 0 20 0; +#X connect 24 0 28 0; +#X connect 25 0 24 0; +#X connect 26 0 24 1; +#X connect 27 0 24 2; +#X connect 32 0 24 0; diff --git a/doc/pddp/help-cputime.pd b/doc/pddp/help-cputime.pd new file mode 100644 index 00000000..45e93136 --- /dev/null +++ b/doc/pddp/help-cputime.pd @@ -0,0 +1,112 @@ +#N canvas 11 8 939 645 10; +#X msg 43 113 bang; +#X msg 18 91 bang; +#X floatatom 18 157 0 0 0; +#X text 90 159 Output is in milliseconds; +#X text 53 91 Click here to start or reset; +#X obj 52 545 time_measurements; +#X obj 52 441 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 17 572 0 0 0; +#X floatatom 108 585 0 0 0; +#X floatatom 175 573 0 0 0; +#X text 11 358 In the example below \, I've created an abstraction +which will force each of PD's stop-watches \, [timer] [cputime] and +[realtime] to measure various processes and report the elapsed time. +Click on each [bng] to begin the process and wait for the results. +Notice the discrepancies in the results.; +#X text 15 587 Logical Time; +#X text 173 587 Real Time; +#X text 107 601 CPU Time; +#X obj 67 477 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 72 435 1 Measures elapsed time between two "bangs" from a [trigger] +object.; +#X text 87 469 2 Measures the amount of time PD requires to turn on +DSP and start an oscillator.; +#X obj 445 484 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 445 17 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 472 36 WHY THE DISCREPANCIES BETWEEN CLOCKS?; +#X text 475 59 In a fantasy world \, computers could exist somehow +beyond the restrictions of time and digital computation could be performed +in ZERO time. However \, that is not the case. Instead \, every process +within PD and within your operating system requires at least a few +nanoseconds of your CPU's time.; +#X obj 111 509 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 476 144 The [timer] object is like a clock that is not constrained +to the regular laws of physics and the universal space-time continuum. +It reports "time" measurements as only PD can see them!; +#X text 477 203 The [cputime] object is like a clock that measures +how much time your CPU actually required to carry out your request. +Keep in mind however that your CPU is busy doing many things simoultaneously +\, so even though a process might take 5 minutes to complete \, your +CPU does not pay full attention to that process for the entire 5 minutes. +Instead \, it simply begins the process \, then refers back to that +process from time to time until the it is complete. In other cases +\, your CPU might require a full 5 minutes while PD might report that +merely a few milliseconds have passed. This type of discrepancy depends +heavily on your computer's hardware and the type of processing it is +performing.; +#X text 478 368 The [realtime] object is as much like your own wrist +watch as PD can possibly manage. It measures time according to your +operating system's internal clock.; +#N canvas 0 0 456 306 related_objects_from_other_libraries 0; +#X text 27 63 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 26 112 The best places to find information about PD's libraries +is:; +#X text 23 134 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 25 149 or; +#X text 25 164 iem.kug.ac.at/pdb/; +#X obj 44 24 t3_timer; +#X text 469 589 This document was updated for PD version 0.35 test +26 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X restore 482 539 pd related_objects_from_other_libraries; +#X text 309 580 This document was updated for PD version 0.35 test +28 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X obj 602 508 metro; +#X text 481 485 RELATED OBJECTS; +#X obj 539 508 realtime; +#X text 132 501 3 Measures the amount of time PD requires count to +three...please wait for approximately 3 seconds.; +#X obj 25 15 cputime; +#X text 80 14 -- measure CPU time; +#X text 13 44 The [cputime] object measures elapsed CPU time. CPU time +is the amount of time your computer's CPU requires to perform a task +-- that's a short definition.; +#X obj 18 135 cputime; +#X text 81 114 Click here to get elapsed CPU time. Click again...and +again...to see periodic measurements from the start or reset time. +Be patient.; +#X text 11 185 [cputime] works like essentially like a stop-watch. +Once it starts \, you can continue to "poll" [cputime] to view the +elapsed time.; +#X text 11 232 The odd aspect about comparing [cputime] to a stop-watch +is that a stop-watch can be stopped! [cputime] can only be started +or reset. It cannot be stopped.; +#X text 10 282 As stated above \, [cputime] measures "CPU" time. This +value may be slightly different than "logical" time or "real" time. +PD offers two objects which measure "logical" time and "real" time. +See the reference documents for those objects for more information. +; +#X obj 481 509 timer; +#X text 472 419 MORE INFORMATION; +#X text 477 438 More information about [cputime] can be found in the +Pure Documentation reference folder 7.stuff/load-meter.pd; +#X connect 0 0 34 1; +#X connect 1 0 34 0; +#X connect 5 0 7 0; +#X connect 5 1 8 0; +#X connect 5 2 9 0; +#X connect 6 0 5 0; +#X connect 14 0 5 1; +#X connect 18 0 17 0; +#X connect 21 0 5 2; +#X connect 34 0 2 0; diff --git a/doc/pddp/help-ctlin.pd b/doc/pddp/help-ctlin.pd new file mode 100644 index 00000000..136ea95d --- /dev/null +++ b/doc/pddp/help-ctlin.pd @@ -0,0 +1,86 @@ +#N canvas 261 0 448 656 10; +#N canvas 240 135 476 472 other_midi_objects 0; +#X obj 55 31 ctlin; +#X obj 97 31 pgmin; +#X obj 140 30 bendin; +#X obj 191 29 touchin; +#X obj 252 29 polytouchin; +#X obj 337 29 midiin; +#X obj 388 28 sysexin; +#X obj 6 85 noteout; +#X obj 63 84 ctlout; +#X obj 161 85 touchout; +#X obj 225 84 polytouchout; +#X obj 314 84 midiout; +#X obj 113 84 pgmout; +#X obj 11 153 makenote; +#X text 10 194 MIDI notes deconstruction:; +#X text 8 128 MIDI note construction:; +#X text 8 58 MIDI output:; +#X text 8 2 MIDI input:; +#X obj 15 226 stripnote; +#X text 11 266 Additional useful objects for MIDI processing (Maxlib +by Olaf Matthes); +#X obj 148 297 chord; +#X obj 109 296 borax; +#X obj 54 296 score o; +#X obj 13 296 pitch; +#X text 15 336 Also \, from cyclone (alpha) by Krzysztof Czaja:; +#X obj 16 359 midiformat; +#X obj 172 359 midiflush; +#X obj 98 359 midiparse; +#X text 15 386 and xeq \, from the same developer; +#X obj 16 411 xeq; +#X text 41 402 an experimental MIDI sequencer; +#X obj 8 31 midiin; +#X restore 88 534 pd other_midi_objects; +#X obj 280 562 midi-basics; +#X text 18 562 for an explanation of MIDI usage in PD see:; +#X obj 28 18 ctlin; +#X obj 19 226 ctlin; +#X floatatom 19 252 5 0 0; +#X floatatom 33 272 5 0 0; +#X floatatom 49 290 5 0 0; +#X text 17 127 Arguments (optional): 1st argument (or only argument) +indicates the controller number to process. The second argument \, +if present \, indicates the channel number on which the controller +is to be processed. If the second argument is absent [ctlin] reads +all channels. If no arguments are preent [ctlin] reads all controller +data on all channels.; +#X text 66 221 Inlets: none. Reads data directly from the MIDI port +; +#X text 66 235 Outlets:; +#X text 116 249 1st (leftmost): Controller value; +#X text 118 265 Middle: controller number; +#X text 118 285 rightmost: Channel number; +#X text 17 317 If one comment is given (ctl. number) [ctlin] provides +the user with only 2 outlets: ctl. value and channel no. If 2 arguments +are given (ctl. no. & chan. no.) only one outlet (ctl. value) is given: +; +#X obj 24 383 ctlin 64; +#X floatatom 24 417 5 0 0; +#X floatatom 74 407 5 0 0; +#X text 97 382 Process only controller no. 64 on all channels; +#X text 7 430 ctl. value; +#X text 83 420 Chan. no.; +#X obj 25 455 ctlin 64 1; +#X text 102 456 Process only controller 64 on channel 1; +#X floatatom 25 481 5 0 0; +#X text 22 496 ctl. value; +#X obj 21 534 ctlout; +#X text 18 515 See also:; +#X text 13 51 The [ctlin] object reads control change messages directly +from the MIDI port. See a MIDI-specification chart near you for control +change message numbers and their meannings (MIDI implementation documents +are freely available on the internet in c=various forms).; +#X text 69 18 - read incoming Control Change messages; +#X text 19 586 This document was updated for PD version 0.35 by Michal +Seta as part of a project called pddp proposed by Krzysztof Czaja \, +managed and edited by Dave Sabine \, to build comprehensive documentation +for PD.; +#X connect 4 0 5 0; +#X connect 4 1 6 0; +#X connect 4 2 7 0; +#X connect 15 0 16 0; +#X connect 15 1 17 0; +#X connect 21 0 23 0; diff --git a/doc/pddp/help-ctlout.pd b/doc/pddp/help-ctlout.pd new file mode 100644 index 00000000..621fb9d7 --- /dev/null +++ b/doc/pddp/help-ctlout.pd @@ -0,0 +1,90 @@ +#N canvas 251 9 495 634 10; +#N canvas 240 135 476 472 other_midi_objects 0; +#X obj 55 31 ctlin; +#X obj 97 31 pgmin; +#X obj 140 30 bendin; +#X obj 191 29 touchin; +#X obj 252 29 polytouchin; +#X obj 337 29 midiin; +#X obj 388 28 sysexin; +#X obj 6 85 noteout; +#X obj 63 84 ctlout; +#X obj 161 85 touchout; +#X obj 225 84 polytouchout; +#X obj 314 84 midiout; +#X obj 113 84 pgmout; +#X obj 11 153 makenote; +#X text 10 194 MIDI notes deconstruction:; +#X text 8 128 MIDI note construction:; +#X text 8 58 MIDI output:; +#X text 8 2 MIDI input:; +#X obj 15 226 stripnote; +#X text 11 266 Additional useful objects for MIDI processing (Maxlib +by Olaf Matthes); +#X obj 148 297 chord; +#X obj 109 296 borax; +#X obj 54 296 score o; +#X obj 13 296 pitch; +#X text 15 336 Also \, from cyclone (alpha) by Krzysztof Czaja:; +#X obj 16 359 midiformat; +#X obj 172 359 midiflush; +#X obj 98 359 midiparse; +#X text 15 386 and xeq \, from the same developer; +#X obj 16 411 xeq; +#X text 41 402 an experimental MIDI sequencer; +#X obj 8 31 midiin; +#X restore 89 430 pd other_midi_objects; +#X obj 285 469 midi-basics; +#X text 21 469 for an explanation of MIDI usage in PD see:; +#X obj 18 16 ctlout; +#X text 14 43 The [ctlout] objects sends control messages to the MIDI +port. See a MIDI specification chart for various controller numbers/values +descriptions.; +#X text 15 89 Arguments (optional):; +#X text 24 105 1st (or only one) argument represents the controller +number to transmit to.; +#X text 24 137 2nd argument designates the channel number to transmit +on. If no channel is specified it transmits on channel 1; +#X floatatom 21 181 5 0 0; +#X obj 21 231 ctlout; +#X floatatom 39 197 5 0 0; +#X floatatom 57 213 5 0 0; +#X text 108 175 Inlets:; +#X text 107 240 Outlets: none. Transmits directly to the MIDI port. +; +#X text 120 192 Left: (int) control value (0-127).; +#X text 120 207 Middle: (int) controller number.; +#X text 120 223 Right: (int) channel number.; +#X text 21 264 NOTE: the left inlet accepts also a list of (2 or 3) +integers where the first item is controller value \, second controller +number and third the channel number.; +#X obj 24 356 ctlout; +#X obj 116 356 ctlout 64; +#X obj 218 356 ctlout 64 2; +#X obj 320 355 ctlout; +#X msg 43 337 64; +#X msg 73 337 2; +#X msg 317 320 67 64 2; +#X floatatom 218 318 5 0 0; +#X floatatom 116 316 5 0 0; +#X floatatom 24 316 5 0 0; +#X msg 173 333 2; +#X text 23 379 All these examples will transmit control no 64 on channel +2 (remember to click the message boxes to initialize).; +#X text 22 411 See also:; +#X obj 25 430 ctlin; +#X text 66 17 - send MIDI control messages to the MIDI port; +#X text 19 515 This document was updated for PD version 0.35 by Michal +Seta as part of a project called pddp proposed by Krzysztof Czaja \, +managed and edited by Dave Sabine \, to build comprehensive documentation +for PD.; +#X connect 8 0 9 0; +#X connect 10 0 9 1; +#X connect 11 0 9 2; +#X connect 22 0 18 1; +#X connect 23 0 18 2; +#X connect 24 0 21 0; +#X connect 25 0 20 0; +#X connect 26 0 19 0; +#X connect 27 0 18 0; +#X connect 28 0 19 2; diff --git a/doc/pddp/help-dac~.pd b/doc/pddp/help-dac~.pd new file mode 100644 index 00000000..a45a4594 --- /dev/null +++ b/doc/pddp/help-dac~.pd @@ -0,0 +1,68 @@ +#N canvas 2 1 613 608 12; +#X obj 104 540 pddp; +#X obj 8 8 cnv 15 90 553 empty empty empty 20 12 0 14 -233017 -66577 +0; +#N canvas 85 2 595 611 More_Info 0; +#X text 16 13 MULTI-CHANNEL AUDIO; +#X text 32 40 All sound cards are capable of at least two channels +of audio. PD supports these two channels by default and uses your system's +generic audio drivers to communicate with your hardware. However \, +for faster input/output and for more than two channels of audio \, +PD incorporates the use of "PortAudio" which uses ASIO drivers to communicate +with your hardware. So \, to instruct PD to use more than two channels +of audio \, your command line should read like below:; +#X text 93 182 c:/pd/bin/pd.exe -pa -inchannels 8 -outchannels 8; +#X text 32 211 The "-pa" switch means "PortAudio". This switch is new +as of PD version 0.37 TEST 4 and replaces the old "-asio" switch.; +#X text 32 271 The "-inchannels" and "-outchannels" switches can be +summarized by using "-channels 8" because currently PortAudio requires +that the number of incoming and outgoing channels must be equal. This +may change in the PD's future...; +#X text 32 361 To further optimize PD's usage of your audio hardware +\, you can explore the following:; +#X text 42 402 - audiobuf; +#X text 43 420 - blocksize; +#X text 42 436 - audioindev; +#X text 42 454 - audiooutdev; +#X text 38 480 With the right hardware \, PD can manage audio input +and output with lower than 10 milliseconds of latency.; +#X restore 104 514 pd More_Info; +#N canvas 85 2 397 246 Related_Objects 0; +#X text 25 8 Native PD Objects; +#X text 25 92 Externals and other object libraries; +#X obj 98 46 switch~; +#X obj 171 46 block~; +#X obj 45 46 adc~; +#X restore 104 488 pd Related_Objects; +#X text 16 107 ARGUMENTS:; +#X text 23 344 EXAMPLES:; +#X text 20 487 SEE ALSO:; +#X text 30 53 PURPOSE:; +#X text 152 541 - Dave Sabine \, May 6 \, 2003; +#X text 153 346 default stereo signals: same as; +#X text 280 435 all channels on an 8-channel device; +#X obj 33 20 dac~; +#X text 108 18 - AUDIO OUTPUT: DIGITAL/ANALOG CONVERTER SIGNAL; +#X text 104 53 [dac~] is an acronym meaning "Digital/Analog Converter +Signal" and is PD's interface to send audio information to the audio +channels of your soundcard(s).; +#X text 106 106 The object defaults to 2 outgoing audio channels (usually +a left and right stereo pair). Any number of arguments (integers) can +be used to define multiple output channels - each integer corresponds +to an output channel on your audio hardware.; +#X text 36 188 INLETS:; +#X text 108 188 Signal: the number of inlets correspond with the number +of arguments - each inlet represents an output channel on your audio +hardware which corresponds to the argument you provide. If no arguments +are provided \, then there are two inlets which represent audio channels +1 and 2 on your computer's sound card.; +#X text 107 290 The information at each inlet should be an audio signal +(i.e. the object operates at 'audio-rate') and therefore must be connected +to an audio outlet on a related object.; +#X obj 109 346 dac~; +#X obj 411 348 dac~ 1 2; +#X obj 109 373 dac~ 5; +#X text 167 374 a mono signal to channel 5; +#X obj 109 404 dac~ 1 3 8 6 11 15 19 22 23 24 36; +#X text 383 405 11 channels of output; +#X obj 109 434 dac~ 1 2 3 4 5 6 7 8; diff --git a/doc/pddp/help-delay.pd b/doc/pddp/help-delay.pd new file mode 100644 index 00000000..e6fb50e8 --- /dev/null +++ b/doc/pddp/help-delay.pd @@ -0,0 +1,139 @@ +#N canvas 9 3 918 652 10; +#X obj 22 14 delay; +#X msg 10 418 bang; +#X floatatom 75 486 0 0 0; +#X text 98 511 <-- creation argument initializes delay time; +#X obj 20 511 delay 1000; +#X text 56 440 Click here to CANCEL delay's action; +#X msg 20 440 stop; +#X msg 31 462 2000; +#X text 67 462 Number in right inlet sets time and schedules the action. +; +#X text 104 486 <-- scroll to change delay time in milliseconds; +#X text 60 14 - BANG AFTER TIME DELAY; +#X obj 20 90 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 20 110 delay 2000; +#X obj 20 133 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 12 42 The [delay] object sends a bang to its outlet after a +delay in milliseconds specified by its right inlet or its creation +argument.; +#X text 15 157 [delay]'s left inlet accepts a number \, or one of two +messages: "bang" or "stop".; +#X text 14 238 The "bang" method will inform [delay] to send a "bang" +to its outlet after the prescribed time (which is set either at its +right inlet \, or in the creation argument). In the above example \, +you should notice a delay of 2 seconds \, then a "bang" at the outlet. +; +#X text 13 314 [delay] accepts only ONE "bang" at a time. It cannot +process multiple delays. In other words \, sending a "bang" to a [delay] +which is already set will reschedule its output \, cancelling the old +one.; +#X text 15 379 The "stop" method will inform [delay] to cancel its +scheduled output.; +#X text 14 191 If a number is sent to its inlet \, [delay] will set +the delay time equal to that number and schedule the outgoing "bang". +; +#X obj 20 536 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 43 419 "bang" to schedule the action; +#X obj 414 9 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 414 613 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 445 15 A MAKESHIFT [METRO]; +#X text 433 35 Let's assume for a moment that Miller had forgotten +to build the [metro] object. (I know that sounds absurd \, but for +the sake of example...); +#X text 433 84 [delay] could be used to create a metronome as follows. +; +#X obj 463 175 bng 15 50 10 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 463 155 delay 1000; +#X msg 427 115 bang; +#X msg 463 115 stop; +#X obj 671 154 metro 1000; +#X obj 671 175 bng 15 50 10 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 671 135 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 +1; +#X floatatom 726 135 5 0 0; +#X floatatom 518 137 5 0 0; +#X text 557 155 is the same as; +#X text 448 206 A RANDOM IMPULSE GENERATOR; +#X text 433 223 Some users might be familiar with SC (SuperCollider) +by James McCartney. For more info about SC \, visit www.audiosynth.com. +Anyways...SC has a unit generator called "DUST". Dust will produce +random impulses at a specified "density". I believe that Dust was given +its name because it creates a sound that is similar to actual dust +on old vinyl LP's -- you know that old crackling sound like Rice Krispies. +; +#X text 432 331 The idea is quite simple. If you want a "very dusty" +sound \, you make the density quite high...if you want a "slightly +dusty" sound \, you make the density quite low.; +#X obj 434 484 delay; +#X obj 434 506 bng 15 50 10 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 434 423 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 +1; +#X text 432 376 Dust.ar(2) in SC will produce 2 dusty impulses randomly +per second. In the example below \, you'll see a version of this process +created using PD's delay object.; +#X obj 434 463 random 500; +#X obj 434 442 metro 500; +#X text 13 563 It is important to realize that [delay] only outputs +a "bang". It cannot be used like an "echo" or to delay messages other +than "bang". For that purpose \, you should explore; +#X obj 63 605 pipe; +#X text 431 528 RELATED OBJECTS; +#X obj 466 548 timer; +#X obj 432 548 pipe; +#X obj 504 548 metro; +#N canvas 0 0 452 302 related_objects_from_other_libraries 0; +#X obj 27 25 nop~; +#X obj 63 25 z~; +#X obj 93 25 t3_delay; +#X obj 153 25 idelay~; +#X text 18 59 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 17 108 The best places to find information about PD's libraries +is:; +#X text 14 130 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 16 160 iem.kug.ac.at/pdb/; +#X restore 432 569 pd related_objects_from_other_libraries; +#X obj 543 548 makenote; +#X obj 603 548 delwrite~; +#X text 445 594 This document was updated for PD version 0.35 test +28 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X floatatom 504 428 5 0 0; +#X text 546 421 low numbers will produce a very "dusty" output.; +#X text 546 433 high numbers will produce a slightly "dusty" output. +; +#X text 546 448 Also note that this example merely approximates the +output of SC's "Dust" object.; +#X connect 1 0 4 0; +#X connect 2 0 4 1; +#X connect 4 0 20 0; +#X connect 6 0 4 0; +#X connect 7 0 4 0; +#X connect 11 0 12 0; +#X connect 12 0 13 0; +#X connect 22 0 23 0; +#X connect 27 0 29 0; +#X connect 28 0 27 0; +#X connect 29 0 28 0; +#X connect 30 0 28 0; +#X connect 31 0 32 0; +#X connect 33 0 31 0; +#X connect 34 0 31 1; +#X connect 35 0 28 1; +#X connect 40 0 41 0; +#X connect 42 0 45 0; +#X connect 44 0 40 0; +#X connect 45 0 44 0; +#X connect 56 0 45 1; +#X connect 56 0 44 1; diff --git a/doc/pddp/help-float.pd b/doc/pddp/help-float.pd new file mode 100644 index 00000000..10630895 --- /dev/null +++ b/doc/pddp/help-float.pd @@ -0,0 +1,88 @@ +#N canvas 0 0 626 624 12; +#X obj 114 560 pddp; +#X obj 8 3 cnv 15 90 578 empty empty empty 20 12 0 14 -233017 -66577 +0; +#X floatatom 325 358 5 0 0 0 - - -; +#X floatatom 484 395 5 0 0 0 - - -; +#X floatatom 369 462 5 0 0 0 - - -; +#X msg 304 402 42 7; +#X obj 366 396 bng 15 250 50 0 empty empty "bang" 0 -6 0 8 -262144 +-1 -1; +#X floatatom 128 422 5 0 0 0 - - -; +#X msg 128 373 bang; +#X obj 46 18 float; +#X obj 492 17 f; +#X text 111 18 - STORE A FLOATING POINT NUMBER - abbreviation:; +#X msg 249 402 7 3 4; +#X obj 369 436 f; +#X obj 128 397 float 7; +#X text 113 484 doc/2.control.examples/sendnumber.pd; +#X text 371 358 Tip: Shift+drag; +#X text 37 44 INLETS:; +#X text 37 59 - LEFT:; +#X text 104 59 Float - A float at the left inlet will update the stored +value of the object and will send the number immediately to the outlet. +; +#X text 104 114 Bang - A bang at the left inlet will force [float] +to send its value to the outlet.; +#X text 104 152 List - A list at the left inlet will be truncated to +include only the first element. The first element in the list will +update the stored value of the object and will send the number immediately +to the outlet.; +#X text 29 220 - RIGHT:; +#X text 105 220 Float - A float at the right inlet is stored for later +use. It will be sent to the left outlet when a float or bang is received +in the left inlet.; +#X text 29 324 OUTLETS:; +#X text 13 272 ARGUMENTS:; +#X text 20 354 EXAMPLES:; +#X text 22 484 SEE ALSO:; +#X text 104 272 One - [float] accepts a single float as a creation +argument which initializes the first value to be sent out the left +outlet.; +#X text 104 325 One - outputs the stored floating point value of the +object.; +#X text 249 384 lists; +#X text 106 355 creation argument; +#N canvas 58 0 401 250 Related_Objects 0; +#X text 25 11 Native PD Objects; +#X text 23 92 Externals and other object libraries; +#X obj 42 48 int; +#X obj 109 48 symbol; +#X text 36 126 [randomF]; +#X restore 114 508 pd Related_Objects; +#N canvas 57 0 637 618 More_Info 0; +#X text 43 24 All numbers in PD are kept in 32-bit floating point and +can represent real numbers between -8 \, 388608 and 8.388.608.00; +#X text 11 78 WHAT IS A FLOATING POINT NUMBER?; +#X text 41 267 The following are examples of floating point numbers: +; +#X text 61 293 3; +#X text 62 334 -111.5; +#X text 61 313 0.5; +#X text 40 387 3e-005 : This example is a computer shorthand for scientific +notation. It means 3*10-5 (or 10 to the negative 5th power multiplied +by 3).; +#X text 41 108 According to Webopedia.com \, "computers are integer +machines and are capable of representing real numbers only by using +complex codes." Hence \, real numbers must be 'approximated' by computers +using the "floating point standard". In such a number \, the decimal +point can "float" meaning that there is no fixed number of digits preceding +or following the decimal. A floating point number is therefore a computer's +approximation of a real number.; +#X text 43 453 Interesting side-note: In the early 1990's \, the Intel +80486 was shipped with a math coprocessor to help accelerate the process +of computing floating point numbers (which previously required a considerable +amount of CPU power.) Math coprocessors have since found there way +into nearly every graphics card and CPU available today.; +#X text 62 358 10000 to 1e-016; +#X restore 114 534 pd More_Info; +#X text 158 561 - Dave Sabine \, November 18 \, 2002; +#X connect 2 0 13 0; +#X connect 3 0 13 1; +#X connect 5 0 13 0; +#X connect 6 0 13 0; +#X connect 8 0 14 0; +#X connect 12 0 13 0; +#X connect 13 0 4 0; +#X connect 14 0 7 0; diff --git a/doc/pddp/help-int.pd b/doc/pddp/help-int.pd new file mode 100644 index 00000000..9e176a59 --- /dev/null +++ b/doc/pddp/help-int.pd @@ -0,0 +1,83 @@ +#N canvas 9 19 907 630 10; +#X msg 33 230 bang; +#X floatatom 23 313 0 0 0; +#X floatatom 23 208 0 0 0; +#X floatatom 47 255 0 0 0; +#X text 71 230 You can force the object to output the stored number. +; +#X text 68 208 You can set and output the value simoultaneously.; +#X text 105 255 You can store the number \, without outputting it. +; +#X text 488 142 NOTE; +#X obj 450 8 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 450 547 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 284 568 This document was updated for PD version 0.35 test +24 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X text 482 480 RELATED OBJECTS; +#X obj 529 507 symbol; +#X text 97 11 - STORE AN INTEGER; +#X obj 55 12 int; +#X text 19 41 The int object stores an integer (which is set either +by its creation argument or by the right inlet) and then outputs that +number when it receives a "bang" message or a new number in its left +inlet.; +#X text 18 98 This object acts exactly as its nearest cousin:; +#X obj 307 97 float; +#X text 495 159 All numbers in PD are kept in 32-bit floating point +and can represent real numbers between -8 \, 388 \, 608 and 8 \, 388 +\, 608 Hence \, the [int] object takes about as much CPU as the [float] +object \; but is useful when numbers need to be truncated and/or when +patches are being designed to be compatible with PD and MAX/MSP.; +#X text 18 160 Tip: Press and hold SHIFT while click-n-dragging these +number boxes to see how the [int] object truncates the number - drops +decimal places.; +#X obj 23 287 int 6.5; +#X text 17 114 with only one exception: All decimal places are dropped! +All fractions will be truncated \; they will not be 'rounded off'. +; +#X obj 491 507 float; +#X obj 573 506 random; +#X text 487 10 WHAT IS AN INTEGER?; +#X text 493 29 Integers are "whole" numbers - numbers which do not +contain fractions. The following are examples of whole numbers:; +#X text 494 59 1; +#X text 494 74 -544; +#X text 494 103 10024; +#X text 493 88 420; +#N canvas 0 0 414 279 related_objects_from_other_libraries 0; +#X obj 22 19 list2int; +#X obj 77 19 i2l; +#X obj 104 19 probalizer; +#X text 20 56 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 19 105 The best places to find information about PD's libraries +is:; +#X text 16 127 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 18 157 iem.kug.ac.at/pdb/; +#X restore 490 529 pd related_objects_from_other_libraries; +#X text 496 283 The [int] object can be used as a basis for building +simple counter mechanisms in PD. In the example below \, the [int] +object's stored value is incremented by 1 with each "bang".; +#X text 87 281 The creation argument initializes the object and stores +the number until the value is reset. The creation argument is optional. +If no creation argument is provided \, the object defaults to zero. +; +#X msg 511 340 bang; +#X obj 511 369 int; +#X obj 539 369 + 1; +#X floatatom 511 395 5 0 0; +#X text 486 263 EXAMPLE: BUILDING A COUNTER; +#X connect 0 0 20 0; +#X connect 2 0 20 0; +#X connect 3 0 20 1; +#X connect 8 0 9 0; +#X connect 20 0 1 0; +#X connect 33 0 34 0; +#X connect 34 0 35 0; +#X connect 34 0 36 0; +#X connect 35 0 34 1; diff --git a/doc/pddp/help-line.pd b/doc/pddp/help-line.pd new file mode 100644 index 00000000..a188ad45 --- /dev/null +++ b/doc/pddp/help-line.pd @@ -0,0 +1,166 @@ +#N canvas 70 32 802 522 10; +#X obj 22 14 line; +#X text 57 14 -- ramp generator; +#X text 17 43 [line]'s left inlet defines the "target" value. The right +inlet defines the "time" value. The "target \, time" pair of numbers +inform [line] to produce a numeric "ramp" from its current value (whatever +that might be at any given moment) to the new value within the alloted +time which is defined at the right inlet.; +#X text 18 131 It is important to realize that [line] stores only the +current value...it does not remember the defined "time" (duration of +the ramp). Hence \, the following works:; +#X obj 26 246 line; +#X msg 60 222 1000; +#X msg 26 222 1000; +#X obj 26 179 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 26 199 t b b; +#X floatatom 26 268 5 0 0; +#X obj 167 254 line; +#X msg 167 230 1000; +#X obj 167 210 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 167 276 5 0 0; +#X text 20 293 If [line] receives a new target value without an accompanying +"time" \, it simply jumps to the new value...as in the example above +on the right. In the example above on the left \, you'll see that [line] +will create a numeric ramp from 0 to 1000 over 1000 milliseconds. You +should also note that if you click that [bng] again a second time \, +nothing happens. This is because [line] is already at 1000 \, so sending +it new instructions to ramp to 1000 is meaningless and has no effect. +; +#X text 18 419 Having said all of that \, let's just reiterate that +it's important to send a "time" value to [line] before sending it a +new "target" value...unless of course you WANT it to jump immediately +to the new target.; +#X text 415 20 [line] will accept a list of two numbers. The first +in the list will be assigned as the new target \, the second in the +list will be the new time (duration of the ramp) as below:; +#X obj 387 11 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 387 473 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 420 187 line; +#X msg 420 99 1000 1000; +#X floatatom 420 208 5 0 0; +#X text 486 98 ramp up.; +#X msg 429 122 0 1000; +#X text 476 122 ramp down.; +#X msg 441 166 stop; +#X text 416 65 [line] will also accept the "stop" message which effectively +halt the current ramp.; +#N canvas 51 105 536 509 continuous_ramps 0; +#X text 29 44 [line] does not schedule its incoming messages. What +this means is that if you send [line] a new target value mid-way through +a ramp \, a new ramp is immediatly created to the new target value +starting from the "current" value.; +#X text 27 105 In other words \, if [line] receives a message specifying +some new target and time before reaching the previous target \, it +takes off from its current value.; +#X obj 34 254 hsl 128 15 0 127 0 0 empty empty empty -2 -6 0 8 -262144 +-1 -1 0 1; +#X msg 64 212 stop; +#X msg 57 192 42; +#X obj 31 233 line; +#X msg 31 151 127 5000; +#X msg 49 172 0 5000; +#X text 18 23 CONTINUOUS RAMPS; +#X text 24 278 Due to this unique behavior \, a common construct found +in PD patches includes the [pack] object as follows:; +#X obj 38 399 line; +#X floatatom 38 420 10 0 0; +#X floatatom 38 313 5 0 0; +#X obj 38 379 pack f 500; +#X msg 49 332 50; +#X msg 57 353 2000; +#X connect 3 0 5 0; +#X connect 4 0 5 0; +#X connect 5 0 2 0; +#X connect 6 0 5 0; +#X connect 7 0 5 0; +#X connect 10 0 11 0; +#X connect 12 0 13 0; +#X connect 13 0 10 0; +#X connect 14 0 13 0; +#X connect 15 0 13 0; +#X restore 404 262 pd continuous_ramps; +#X text 168 180 While this does NOT work unless; +#X text 166 190 you click "500" first.; +#X msg 201 230 500; +#X msg 437 145 42; +#X text 463 146 jumps to this value immediately.; +#X text 478 166 stops the current ramp.; +#X text 403 288 More information about [line] can be found in the Pure +Documentation folder doc/3.audio.examples.; +#X text 412 450 This document was updated for PD version 0.35 test +28 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X text 404 326 RELATED OBJECTS; +#X obj 405 346 line~; +#N canvas 0 0 452 302 related_objects_from_other_libraries 0; +#X obj 23 21 tripleline; +#X obj 105 20 t3_line~; +#X obj 171 20 fade~; +#X obj 219 21 step; +#X text 17 54 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 16 103 The best places to find information about PD's libraries +is:; +#X text 13 125 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 14 141 or; +#X text 15 155 iem.kug.ac.at/pdb/; +#X restore 406 370 pd related_objects_from_other_libraries; +#N canvas 0 0 454 528 grain_rate_and_creation_arguments 0; +#X text 20 18 GRAIN RATE; +#X text 32 38 The "grain rate" of [line] is the rate at which it will +output its values. The faster the grain is \, the smoother the ramp +will appear. While slower grain rates will produce a more disjunct +ramp. Of course this setting will alter the amount of CPU that the +[line] object will require. Higher rates require more computation. +; +#X text 33 144 This means simply that [line] will output a new value +between its current value and your new value once every 20 milliseconds. +; +#X text 33 125 The default grain rate is 20 milliseconds.; +#X text 30 192 [line]'s optional creation arguments can be used to +reset the grain rate. However \, the grain rate cannot be reset dynamically. +; +#X text 32 247 First creation argument is the initial value: the starting +point of the first ramp.; +#X text 31 286 The second creation argument sets the grain rate. Observe +the following two examples to see how the grain rate effects the output. +; +#X obj 44 417 line 0 5; +#X obj 47 450 hsl 128 15 0 127 0 0 empty empty empty -2 -6 0 8 -262144 +-1 -1 0 1; +#X msg 147 346 127; +#X msg 179 354 0; +#X obj 146 382 pack f 5000; +#X obj 214 450 hsl 128 15 0 127 0 0 empty empty empty -2 -6 0 8 -262144 +-1 -1 0 1; +#X obj 211 417 line 0 500; +#X connect 7 0 8 0; +#X connect 9 0 11 0; +#X connect 10 0 11 0; +#X connect 11 0 7 0; +#X connect 11 0 13 0; +#X connect 13 0 12 0; +#X restore 404 235 pd grain_rate_and_creation_arguments; +#X connect 4 0 9 0; +#X connect 5 0 4 1; +#X connect 6 0 4 0; +#X connect 7 0 8 0; +#X connect 8 0 6 0; +#X connect 8 1 5 0; +#X connect 10 0 13 0; +#X connect 11 0 10 0; +#X connect 12 0 11 0; +#X connect 17 0 18 0; +#X connect 19 0 21 0; +#X connect 20 0 19 0; +#X connect 23 0 19 0; +#X connect 25 0 19 0; +#X connect 30 0 10 1; +#X connect 31 0 19 0; diff --git a/doc/pddp/help-loadbang.pd b/doc/pddp/help-loadbang.pd new file mode 100644 index 00000000..e6509ed1 --- /dev/null +++ b/doc/pddp/help-loadbang.pd @@ -0,0 +1,97 @@ +#N canvas 2 1 603 598 12; +#X text 108 18 - SEND "bang" AUTOMATICALLY WHEN PATCH LOADS.; +#X obj 126 218 loadbang; +#X obj 126 385 loadbang; +#X obj 126 410 metro 1000; +#X obj 126 434 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 126 266 f 1; +#X obj 169 266 f 4; +#X obj 126 291 +; +#X floatatom 126 315 5 0 0 0 - - -; +#X obj 126 241 t b b; +#X obj 104 540 pddp; +#X obj 8 8 cnv 15 90 553 empty empty empty 20 12 0 14 -233017 -66577 +0; +#X obj 21 18 loadbang; +#X text 104 464 PD Documentation Chapter 3.6 - doc/1.manual/x3.htm +; +#X text 104 53 The inlet is inactive and serves no purpose.; +#X text 104 81 This object does not accept arguments of any type.; +#X text 104 112 A "bang" message is sent automatically when the containing +patch is loaded.; +#X text 104 161 In this example \, [loadbang] was used to process a +simple mathematic equation when this patch was loaded. In this case: +1 + 4 = 5; +#X text 104 344 In this example \, [loadbang] was used simply to start +a process automatically when this patch was loaded.; +#X text 152 541 - Dave Sabine \, November 12 \, 2002; +#N canvas 85 2 579 656 More_Info 0; +#X obj 25 152 print foo; +#X obj 25 104 loadbang; +#X text 14 188 As well \, the following [float]s were set with a group +of numbers. Click the [bng] below to verify that the numbers were stored +in the [float] objects.; +#X obj 26 355 f; +#X floatatom 26 380 2 0 0 0 - - -; +#X obj 65 355 f; +#X floatatom 65 380 2 0 0 0 - - -; +#X obj 105 355 f; +#X floatatom 104 380 2 0 0 0 - - -; +#X obj 26 263 bng 15 250 50 0 empty empty Click_here_to_see_the_numbers_stored_in_the_float_objects. +0 -6 0 8 -262144 -1 -1; +#X obj 195 316 random 10; +#X obj 104 317 random 10; +#X text 14 415 IMPORTANT; +#X text 44 600 c:/pd/pd.exe -noloadbang; +#X text 14 10 The loadbang object will send a "bang" message when a +canvas/patch loads and is used most often to 'initialize' or set default +values in a patch. For example \, when you opened this patch \, the +message below was immediately printed in the terminal window.; +#X obj 104 283 loadbang; +#X obj 288 317 random 10; +#X text 14 438 Loadbangs are a useful tool to set initial values in +a patch - however \, there are times when it might be necessary to +debug a patch and "turn off" all the loadbang objects. This can be +accomplished by opening PD with the -noloadbang flag.; +#X text 14 523 For example \, to suppress all loadbangs \, your command +line might look something like this: (more info about PD's command +line can be found in Chapter 3.6 of the HTML documentation.; +#X msg 25 127 you have opened the [loadbang] help document; +#X connect 1 0 19 0; +#X connect 3 0 4 0; +#X connect 5 0 6 0; +#X connect 7 0 8 0; +#X connect 9 0 3 0; +#X connect 9 0 5 0; +#X connect 9 0 7 0; +#X connect 10 0 5 1; +#X connect 11 0 3 1; +#X connect 15 0 11 0; +#X connect 15 0 10 0; +#X connect 15 0 16 0; +#X connect 16 0 7 1; +#X connect 19 0 0 0; +#X restore 104 514 pd More_Info; +#N canvas 85 2 389 238 Related_Objects 0; +#X obj 44 49 bang; +#X obj 102 51 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 143 48 trigger; +#X text 25 8 Native PD Objects; +#X text 25 92 Externals and other object libraries; +#X text 36 126 [init]; +#X restore 104 488 pd Related_Objects; +#X text 38 53 INLETS:; +#X text 14 82 ARGUMENTS:; +#X text 29 112 OUTLETS:; +#X text 20 161 EXAMPLES:; +#X text 21 463 SEE ALSO:; +#X connect 1 0 9 0; +#X connect 2 0 3 0; +#X connect 3 0 4 0; +#X connect 5 0 7 0; +#X connect 6 0 7 1; +#X connect 7 0 8 0; +#X connect 9 0 5 0; +#X connect 9 1 6 0; diff --git a/doc/pddp/help-makefilename.pd b/doc/pddp/help-makefilename.pd new file mode 100644 index 00000000..dc73e3f4 --- /dev/null +++ b/doc/pddp/help-makefilename.pd @@ -0,0 +1,244 @@ +#N canvas 2 0 609 604 12; +#X obj 104 539 pddp; +#X obj 8 8 cnv 15 90 553 empty empty empty 20 12 0 14 -233017 -66577 +0; +#X text 104 463 PD Documentation Chapter 3.6 - doc/1.manual/x3.htm +; +#N canvas 85 2 593 608 More_Info 1; +#X text 17 24 COMMON USES; +#X text 15 417 INNOVATIVE USES; +#X text 47 47 I believe that this object was developed first to allow +PD to generate sequential file names - perhaps to be used in conjunction +with [soundfiler] or [openpanel]. For example \, an audio loop recorder +might generate a continuous series of sound files to be saved on a +hard drive...like below:; +#X obj 54 136 bng 15 250 50 0 empty empty Bang_me 18 7 0 8 -262144 +-1 -1; +#X obj 54 160 f; +#X symbolatom 54 215 0 0 0 0 - - -; +#X text 53 238 This file name could be used when saving the audio data +to disk.; +#X obj 87 161 + 1; +#X obj 54 187 makefilename file-%d.aif; +#X text 20 280 LIMITATIONS; +#N canvas 175 3 583 599 spaces_and_multiple_variables 0; +#X text 25 19 Instead of using spaces \, an underscore will often produce +a tolerable compromise.; +#X obj 210 40 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 210 64 f; +#X symbolatom 210 119 0 0 0 0 - - -; +#X obj 243 64 + 1; +#X obj 210 91 makefilename I_am_%d_years_old.; +#X text 28 143 With careful planning \, multiple variables can be incorporated +using a stack of [makefilename]s. In the example below \, let's assume +that this tool is used to generate file names for an audio loop recorder +which operates 24 hours per day \, every day.; +#X obj 31 235 loadbang; +#X obj 31 280 metro 200; +#X obj 31 261 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 1 1 +; +#X obj 64 305 + 1; +#X obj 209 349 route 0 1 2 3 4 5 6; +#X obj 31 354 mod 24; +#X floatatom 31 379 5 0 0 0 - - -; +#X floatatom 31 329 0 0 0 0 - - -; +#X obj 31 305 f; +#X obj 53 405 sel 0; +#X obj 218 269 f; +#X obj 250 269 + 1; +#X obj 218 294 mod 7; +#X obj 218 322 pack f f; +#X obj 230 498 makefilename Monday_%d.wav; +#X symbolatom 65 548 0 0 0 0 - - -; +#X obj 334 374 makefilename Saturday_%d.wav; +#X obj 314 399 makefilename Friday_%d.wav; +#X obj 290 326 t b f; +#X obj 293 424 makefilename Thursday_%d.wav; +#X obj 272 449 makefilename Wednesday_%d.wav; +#X obj 251 474 makefilename Tuesday_%d.wav; +#X obj 209 522 makefilename Sunday_%d.wav; +#X text 81 377 hour of day; +#X text 79 330 total hours; +#X text 199 549 Crude...but effective.; +#X obj 31 455 s dayHour; +#X obj 53 430 s weekDay; +#X obj 218 236 r weekDay; +#X obj 290 300 r dayHour; +#X text 284 271 loop through weekdays; +#X connect 1 0 2 0; +#X connect 2 0 4 0; +#X connect 2 0 5 0; +#X connect 4 0 2 1; +#X connect 5 0 3 0; +#X connect 7 0 9 0; +#X connect 8 0 15 0; +#X connect 9 0 8 0; +#X connect 10 0 15 1; +#X connect 11 0 29 0; +#X connect 11 1 21 0; +#X connect 11 2 28 0; +#X connect 11 3 27 0; +#X connect 11 4 26 0; +#X connect 11 5 24 0; +#X connect 11 6 23 0; +#X connect 12 0 13 0; +#X connect 13 0 16 0; +#X connect 13 0 33 0; +#X connect 14 0 12 0; +#X connect 15 0 10 0; +#X connect 15 0 14 0; +#X connect 16 0 34 0; +#X connect 17 0 18 0; +#X connect 17 0 19 0; +#X connect 18 0 17 1; +#X connect 19 0 20 0; +#X connect 20 0 11 0; +#X connect 21 0 22 0; +#X connect 23 0 22 0; +#X connect 24 0 22 0; +#X connect 25 0 20 0; +#X connect 25 1 20 1; +#X connect 26 0 22 0; +#X connect 27 0 22 0; +#X connect 28 0 22 0; +#X connect 29 0 22 0; +#X connect 35 0 17 0; +#X connect 36 0 25 0; +#X restore 47 445 pd spaces_and_multiple_variables; +#N canvas 175 4 503 605 help_with_interfaces 1; +#X text 17 16 Building user interfaces in PD is a difficult balance +between usability and performance. PD is not winning any awards for +usability - let's face it: it's powerful \, it's cool \, and that's +the way we like it. You're not here because you want a colourful \, +bevelled interface...you want the raw power that object oriented languages +provide mixed with a few of the conveniences that a graphic environment +affords.; +#X obj 17 269 cnv 15 450 300 empty empty empty 20 12 0 14 -261681 -66577 +0; +#X obj 45 379 tgl 15 0 s_dsp empty DSP 18 7 128 8 -262144 -1 -1 0 1 +; +#X obj 45 424 vsl 15 128 0 127 0 0 v_slider empty Volume 18 7 128 8 +-262144 -1 -1 0 1; +#X obj 45 401 bng 15 250 50 0 b_panel empty Open_File 18 7 128 8 -262144 +-1 -1; +#X obj 40 280 cnv 15 400 20 empty d_canvas DSP 20 12 64 8 -233017 -66577 +0; +#X obj 40 302 cnv 15 400 20 empty f_canvas FILE_OPEN 20 12 64 8 -233017 +-66577 0; +#X obj 40 324 cnv 15 400 20 empty v_canvas VOLUME 20 12 64 8 -233017 +-66577 0; +#X text 187 361 The grey canvases above could; +#X text 189 383 be used like "status bars" to; +#X text 189 404 write relevant information to; +#X text 186 460 [makefilename] helps to format; +#X text 188 484 the information in a meaningful; +#X text 189 505 way.; +#X text 187 426 the screen.; +#N canvas 217 9 470 320 look_inside 0; +#X obj 199 14 r b_panel; +#X obj 235 166 r v_slider; +#X obj 36 236 s d_canvas; +#X obj 199 114 s f_canvas; +#X obj 235 263 s v_canvas; +#X obj 36 80 sel 0; +#X obj 71 152 symbol ON; +#X obj 36 128 symbol OFF; +#X obj 71 103 bang; +#X msg 36 210 label \$1; +#X obj 36 184 makefilename DSP:%s; +#X obj 36 13 r s_dsp; +#X msg 45 38 \; pd dsp \$1; +#X obj 199 40 openpanel; +#X obj 199 65 makefilename FILE_OPEN:%s; +#X msg 199 90 label \$1; +#X msg 235 240 label \$1; +#X obj 235 192 expr ($f1/128)*100; +#X obj 235 217 makefilename VOLUME:%d/100; +#X connect 0 0 13 0; +#X connect 1 0 17 0; +#X connect 5 0 7 0; +#X connect 5 1 8 0; +#X connect 6 0 10 0; +#X connect 7 0 10 0; +#X connect 8 0 6 0; +#X connect 9 0 2 0; +#X connect 10 0 9 0; +#X connect 11 0 5 0; +#X connect 11 0 12 0; +#X connect 13 0 14 0; +#X connect 14 0 15 0; +#X connect 15 0 3 0; +#X connect 16 0 4 0; +#X connect 17 0 18 0; +#X connect 18 0 16 0; +#X restore 40 350 pd look_inside; +#X text 18 156 However \, there are times when sacrifices must be made +in the area of performance to provide users with on-screen reporting +\, record keeping \, and sometimes even a few 'pleasantries'. Consider +the following examples - but always weight the pros and cons when incorporating +these types of interfaces. Performance vs. Usability.; +#X restore 47 477 pd help_with_interfaces; +#X text 45 304 This object does not provide advanced formatting and +parsing abilities. For example \, you cannot use spaces or odd characters +in the argument - also the argument can only include ONE variable. +Although \, these limitations can be easily overcome with a little +ingenuity and compromise -- see below.; +#X connect 3 0 4 0; +#X connect 4 0 7 0; +#X connect 4 0 8 0; +#X connect 7 0 4 1; +#X connect 8 0 5 0; +#X restore 104 513 pd More_Info; +#N canvas 85 2 393 242 Related_Objects 0; +#X text 25 8 Native PD Objects; +#X text 25 92 Externals and other object libraries; +#X text 35 125 [strcat]; +#X obj 42 46 symbol; +#X obj 112 46 int; +#X obj 156 46 openpanel; +#X text 34 151 [makesymbol]; +#X restore 104 487 pd Related_Objects; +#X text 38 53 INLETS:; +#X text 15 197 ARGUMENTS:; +#X text 29 316 OUTLETS:; +#X text 22 342 EXAMPLES:; +#X text 21 462 SEE ALSO:; +#X obj 5 18 makefilename; +#X text 115 18 - FORMAT A STRING WITH A VARIABLE FIELD.; +#X text 104 316 Symbol - The output is formatted like "symbol YOURSTRING". +; +#X floatatom 114 346 0 0 0 0 - - -; +#X obj 114 400 print; +#X obj 114 373 makefilename soundfile%d.aif; +#X text 170 400 numbered filenames; +#X obj 353 431 print; +#X text 406 433 text examples; +#X obj 353 380 symbol; +#X msg 353 343 dave; +#X msg 412 341 drums; +#X msg 479 344 PD; +#X msg 526 355 cool; +#X obj 353 404 makefilename %s_PD.aif; +#X text 107 198 This object generates symbols according to a format +string (the argument) \, for use as a series of filenames \, table +names \, or whatnot. You can plug in a variable number or symbol by +putting "%d" or "%s" in the string. If you put "%s" in the string \, +be sure to send it a symbol and vice versa... there' no checking. Each +[makefilename] object can have only one variable.; +#X text 152 540 - Dave Sabine \, April 25 \, 2003; +#X text 108 53 Integer - If a number is sent to the inlet \, the argument +should be written with a "%d" which represents the location of the +incoming variable number in the outgoing symbol. Floats will be converted +to integers.; +#X text 107 126 Symbol - If a symbol is sent to the inlet \, the argument +should be written with a "%s" which represent the location of the incoming +variable symbol in the outgoing symbol. Lists will be truncated.; +#X connect 13 0 15 0; +#X connect 15 0 14 0; +#X connect 19 0 24 0; +#X connect 20 0 19 0; +#X connect 21 0 19 0; +#X connect 22 0 19 0; +#X connect 23 0 19 0; +#X connect 24 0 17 0; diff --git a/doc/pddp/help-math.pd b/doc/pddp/help-math.pd new file mode 100644 index 00000000..48edb0b4 --- /dev/null +++ b/doc/pddp/help-math.pd @@ -0,0 +1,162 @@ +#N canvas 3 1 906 656 10; +#X floatatom 517 224 0 0 0; +#X floatatom 440 309 0 0 0; +#X floatatom 440 223 0 0 0; +#X floatatom 559 464 0 0 0; +#X floatatom 616 464 0 0 0; +#X floatatom 710 464 0 0 0; +#X floatatom 249 242 0 0 0; +#X floatatom 249 203 0 0 0; +#X floatatom 478 464 0 0 0; +#X floatatom 478 414 0 0 0; +#X floatatom 741 133 0 0 0; +#X floatatom 648 134 0 0 0; +#X obj 555 99 sin; +#X floatatom 432 54 0 0 0; +#X floatatom 555 133 0 0 0; +#X obj 432 94 * 6.28319; +#X obj 432 74 / 360; +#X obj 648 100 cos; +#X obj 741 99 tan; +#X obj 478 444 sqrt; +#X obj 249 222 atan; +#X obj 710 445 log; +#X obj 616 444 exp; +#X obj 559 444 abs; +#X obj 440 261 float; +#X obj 517 261 t b f; +#X obj 440 289 atan2; +#X text 32 14 Higher math in Pd --; +#X obj 162 14 sin; +#X obj 188 14 cos; +#X obj 214 14 tan; +#X obj 241 14 atan; +#X obj 274 14 atan2; +#X obj 314 14 exp; +#X obj 342 14 log; +#X obj 369 14 abs; +#X obj 397 14 sqrt; +#X obj 432 14 pow; +#X text 495 94 2 x Pi; +#X text 21 46 Trigonometry functions take input in Radians. To find +a radian \, simply divide a number by 360 (to make it a fraction of +a circle) and multiply it by 2(Pi) where Pi is equal to approximately +3.14159265.; +#X floatatom 432 114 0 0 0; +#X text 495 114 Radian; +#X obj 432 134 s radians; +#X obj 555 73 r radians; +#X text 20 139 [tan] will produce a number which represents the tangent +of an angle.; +#X text 20 105 [sin] and [cos] will return numbers between -1 and 1: +the sine and cosine of a number repectively.; +#X text 20 186 The [atan] object produces the arctangent of a number +as a numeric value between -Pi/2 and Pi/2.; +#X text 71 284 The [atan2] object produces the arctangent of the quotient +of its two arguments. The number produced is a value between Pi and +-Pi and represents the counterclockwise angle in radians (not degrees) +between the positive X axis and the point (x \, y). Note that the X +coordinate is passed to the right inlet and the Y coordinate is passed +to the left inlet.; +#X text 425 223 Y; +#X text 506 223 X; +#X floatatom 759 329 0 0 0; +#X obj 759 289 /; +#X obj 759 309 atan; +#X obj 759 209 r X_Y; +#X obj 517 309 s X_Y; +#X obj 517 288 pack f f; +#X obj 759 228 unpack f f; +#X obj 759 247 swap; +#X text 585 223 This example on the; +#X text 584 239 right is an alternative; +#X text 584 257 of finding the arctangent; +#X text 584 274 of two coordinates \, but; +#X text 585 291 it runs slightly slower; +#X text 585 307 than [atan2].; +#X text 782 290 Y; +#X text 746 290 X; +#X floatatom 795 268 0 0 0; +#X floatatom 759 268 0 0 0; +#X obj 6 169 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 846 184 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 8 368 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 848 383 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 782 463 0 0 0; +#X text 19 392 [sqrt] will output the square root of a number. Negative +numbers are ignored.; +#X text 416 391 [abs] will output the absolute value of a number.; +#X text 611 488 i; +#X text 418 491 [exp] will output the value of E where E is Euler's +constant and i is the value of the inlet.; +#X text 18 427 [log] will output the natural logarithm (base E) of +a number. The value of zero will produce "-1000" which represents "negative +infinity".; +#X obj 782 443 pow 2; +#X floatatom 807 423 0 0 0; +#X text 17 474 [pow] is used to exponentiate a number. 2 to the power +of 2 = 4 The right inlet or creation argument is the exponent while +the left inlet is the base.; +#X obj 10 515 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 850 530 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 16 537 RELATED OBJECTS; +#X obj 18 557 cos~; +#X obj 50 557 osc~; +#X obj 18 577 +; +#X text 40 577 Other Math Objects; +#X obj 18 597 <; +#X text 41 597 Math/Binary operators; +#X obj 84 557 expr; +#X text 420 563 This document was updated for PD version 0.35 test +28 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X connect 0 0 25 0; +#X connect 2 0 24 0; +#X connect 7 0 20 0; +#X connect 9 0 19 0; +#X connect 9 0 23 0; +#X connect 9 0 22 0; +#X connect 9 0 21 0; +#X connect 9 0 78 0; +#X connect 12 0 14 0; +#X connect 13 0 16 0; +#X connect 15 0 40 0; +#X connect 16 0 15 0; +#X connect 17 0 11 0; +#X connect 18 0 10 0; +#X connect 19 0 8 0; +#X connect 20 0 6 0; +#X connect 21 0 5 0; +#X connect 22 0 4 0; +#X connect 23 0 3 0; +#X connect 24 0 26 0; +#X connect 24 0 55 0; +#X connect 25 0 24 0; +#X connect 25 1 26 1; +#X connect 25 1 55 1; +#X connect 26 0 1 0; +#X connect 40 0 42 0; +#X connect 43 0 12 0; +#X connect 43 0 17 0; +#X connect 43 0 18 0; +#X connect 51 0 52 0; +#X connect 52 0 50 0; +#X connect 53 0 56 0; +#X connect 55 0 54 0; +#X connect 56 0 57 0; +#X connect 56 1 57 1; +#X connect 57 0 67 0; +#X connect 57 1 66 0; +#X connect 66 0 51 1; +#X connect 67 0 51 0; +#X connect 68 0 69 0; +#X connect 70 0 71 0; +#X connect 78 0 72 0; +#X connect 79 0 78 1; +#X connect 81 0 82 0; diff --git a/doc/pddp/help-metro.pd b/doc/pddp/help-metro.pd new file mode 100644 index 00000000..bb734751 --- /dev/null +++ b/doc/pddp/help-metro.pd @@ -0,0 +1,50 @@ +#N canvas 39 7 462 531 10; +#X obj 22 294 metro 500; +#X obj 37 13 metro; +#X floatatom 71 271 4 0 0; +#X msg 22 176 1; +#X text 67 185 nonzero number or "bang" to start; +#X msg 39 223 0; +#X msg 28 199 bang; +#X msg 39 245 stop; +#X text 111 270 right inlet sets the rate in msec per tick.; +#X text 76 13 -- send "bang" periodically ala metronome.; +#X text 19 89 [metro]'s left inlet accepts four different messages: +; +#X text 22 105 - "bang": starts the metro/turns it on.; +#X text 22 118 - "stop": stops the metro/turns it off.; +#X obj 22 317 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 21 45 The metro object sends a series of bangs at a constant +rate which is defined in milliseconds at the right inlet or in the +creation argument.; +#X text 22 131 - Non-Zero number: starts the metro/turns it on.; +#X text 22 143 - 0 (zero): stops the metro/turns it off.; +#X text 78 233 zero or "stop" to stop; +#X text 90 293 optional creation argument initializes rate in msec +; +#X text 19 348 RELATED OBJECTS; +#N canvas 0 0 454 304 related_objects_from_other_libraries 0; +#X obj 35 27 metroplus; +#X obj 102 27 t3_metro; +#X obj 164 27 pulse; +#X text 18 56 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 17 105 The best places to find information about PD's libraries +is:; +#X text 14 127 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 15 143 or; +#X text 16 157 iem.kug.ac.at/pdb/; +#X obj 210 25 exciter; +#X restore 23 372 pd related_objects_from_other_libraries; +#X text 18 402 This document was updated for PD version 0.35 test 28 +by Dave Sabine as part of a project called pddp proposed to build comprehensive +documentation for PD.; +#X connect 0 0 13 0; +#X connect 2 0 0 1; +#X connect 3 0 0 0; +#X connect 5 0 0 0; +#X connect 6 0 0 0; +#X connect 7 0 0 0; diff --git a/doc/pddp/help-midi.pd b/doc/pddp/help-midi.pd new file mode 100644 index 00000000..a2d88092 --- /dev/null +++ b/doc/pddp/help-midi.pd @@ -0,0 +1,121 @@ +#N canvas 14 15 880 473 10; +#X text 718 77 off; +#X floatatom 683 127 0 0 0 0 - - -; +#X obj 683 232 noteout; +#X obj 683 206 makenote 64 250; +#X obj 683 153 metro 500; +#X msg 683 100 1; +#X msg 715 100 0; +#X text 683 77 on; +#X msg 683 180 60; +#X text 31 14 MIDI I/O objects; +#X floatatom 463 129 0 0 0 0 - - -; +#X floatatom 426 129 0 0 0 0 - - -; +#X floatatom 536 131 0 0 0 0 - - -; +#X floatatom 497 129 0 0 0 0 - - -; +#X floatatom 574 132 0 0 0 0 - - -; +#X obj 426 102 touchin; +#X obj 497 103 polytouchin; +#X text 425 79 channel and poly aftertouch; +#X floatatom 427 156 0 0 0 0 - - -; +#X floatatom 498 156 0 0 0 0 - - -; +#X obj 427 182 touchout; +#X obj 498 182 polytouchout; +#X floatatom 537 157 0 0 0 0 - - -; +#X floatatom 575 157 0 0 0 0 - - -; +#X obj 428 283 midiin; +#X floatatom 428 314 0 0 0 0 - - -; +#X floatatom 459 314 0 0 0 0 - - -; +#X floatatom 501 312 0 0 0 0 - - -; +#X floatatom 537 312 0 0 0 0 - - -; +#X text 424 220 These two are always omni and; +#X text 423 236 output the port number instead; +#X obj 503 281 sysexin; +#X obj 430 404 midiout; +#X text 428 338 use this to output raw MIDI; +#X text 423 358 (the second inlet is the port; +#X text 676 424 updated for Pd release 0.35; +#X obj 393 23 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 393 426 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 20 46 This document is currently under revision by the PDDP +(Pure Data Documentation Project). Please stay posted for available +updates.; +#X text 20 101 DOCUMENTED MIDI OBJECTS; +#X text 430 44 MIDI OBJECTS NOT YET DOCUMENTED; +#X text 424 254 of the channel (Linux only):; +#X text 426 376 number.) (Linux Only):; +#X obj 647 23 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 647 426 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 676 44 THE [MAKENOTE] APPARATUS; +#N canvas 0 0 458 308 window_controls 0; +#X obj 149 59 inlet; +#X obj 192 119 inlet; +#X msg 149 233 \; pd open \$1 \$2; +#X obj 149 79 pack s; +#X obj 149 99 makefilename %s.pd; +#X obj 149 213 pack s s; +#X obj 192 193 pack s; +#X obj 251 150 loadbang; +#X msg 192 173 C:/pd/doc/5.reference; +#X obj 198 139 delay 20; +#X connect 0 0 3 0; +#X connect 1 0 8 0; +#X connect 1 0 9 0; +#X connect 3 0 4 0; +#X connect 4 0 5 0; +#X connect 5 0 2 0; +#X connect 6 0 5 1; +#X connect 7 0 8 0; +#X connect 8 0 6 0; +#X connect 9 0 8 0; +#X restore 40 433 pd window_controls; +#X text 144 346 If you have installed PD into; +#X text 143 361 a unique location \, type the path; +#X text 144 377 here to your 5.reference folder; +#X text 141 394 and then save this patch.; +#X text 244 119 Click the object's name; +#X text 243 135 to view its help document.; +#X msg 143 413 set C:/pd/doc/5.reference; +#X msg 161 120 help-bendin; +#X msg 161 144 help-bendout; +#X msg 161 169 help-ctlin; +#X msg 162 194 help-ctlout; +#X msg 162 219 help-notein; +#X msg 162 244 help-noteout; +#X msg 162 269 help-pgmin; +#X msg 163 295 help-pgmout; +#X connect 1 0 4 0; +#X connect 3 0 2 0; +#X connect 3 1 2 1; +#X connect 4 0 8 0; +#X connect 5 0 1 0; +#X connect 6 0 1 0; +#X connect 8 0 3 0; +#X connect 15 0 11 0; +#X connect 15 1 10 0; +#X connect 16 0 13 0; +#X connect 16 1 12 0; +#X connect 16 2 14 0; +#X connect 18 0 20 0; +#X connect 19 0 21 0; +#X connect 22 0 21 1; +#X connect 23 0 21 2; +#X connect 24 0 25 0; +#X connect 24 1 26 0; +#X connect 31 0 27 0; +#X connect 31 1 28 0; +#X connect 36 0 37 0; +#X connect 43 0 44 0; +#X connect 53 0 46 1; +#X connect 54 0 46 0; +#X connect 55 0 46 0; +#X connect 56 0 46 0; +#X connect 57 0 46 0; +#X connect 58 0 46 0; +#X connect 59 0 46 0; +#X connect 60 0 46 0; +#X connect 61 0 46 0; diff --git a/doc/pddp/help-moses.pd b/doc/pddp/help-moses.pd new file mode 100644 index 00000000..e553fac6 --- /dev/null +++ b/doc/pddp/help-moses.pd @@ -0,0 +1,57 @@ +#N canvas 10 0 452 619 10; +#X obj 29 141 moses 10; +#X floatatom 29 121 4 0 0; +#X floatatom 83 120 4 0 0; +#X floatatom 29 166 4 0 0; +#X floatatom 83 166 4 0 0; +#X obj 30 15 moses; +#X text 71 15 - part a stream of numbers; +#X text 19 44 Moses takes numbers and outputs them at left if they're +less than a control value \, and at right if they're greater or equal +to it. The creation argument initializes the control value (10 in this +example) and the right inlet changes it.; +#X obj 27 301 moses 0; +#X floatatom 27 325 5 0 0; +#X floatatom 70 325 5 0 0; +#X floatatom 27 279 5 0 0; +#X text 17 189 One way to think of [moses] is as a filter. For the +following example \, imagine that [moses] works as a low pass and high +pass filter simoultaneously -- for non-audio signals. Below you will +see that negative numbers will pass through the left outlet while positive +numbers will pass through the right outlet.; +#X text 17 348 Before the days of [moses] \, the same effect would +require a completely different structure \, as in the example below: +; +#X floatatom 25 384 5 0 0; +#X floatatom 25 433 5 0 0; +#X obj 25 408 min -1; +#X obj 74 409 max 0; +#X floatatom 74 433 5 0 0; +#X text 73 383 An ol'fashioned way of achieving a similar result.; +#X text 16 474 RELATED OBJECTS; +#N canvas 0 0 454 304 related_objects_from_other_libraries 0; +#X obj 34 29 split; +#X text 18 86 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 17 135 The best places to find information about PD's libraries +is:; +#X text 14 157 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 15 173 or; +#X text 16 187 iem.kug.ac.at/pdb/; +#X restore 22 494 pd related_objects_from_other_libraries; +#X text 18 530 This document was updated for PD version 0.35 test 26 +by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X connect 0 0 3 0; +#X connect 0 1 4 0; +#X connect 1 0 0 0; +#X connect 2 0 0 1; +#X connect 8 0 9 0; +#X connect 8 1 10 0; +#X connect 11 0 8 0; +#X connect 14 0 16 0; +#X connect 14 0 17 0; +#X connect 16 0 15 0; +#X connect 17 0 18 0; diff --git a/doc/pddp/help-notein.pd b/doc/pddp/help-notein.pd new file mode 100644 index 00000000..e727db7d --- /dev/null +++ b/doc/pddp/help-notein.pd @@ -0,0 +1,85 @@ +#N canvas 255 1 494 655 10; +#X obj 32 12 notein; +#X text 133 97 inlets : none; +#X text 134 122 outlets:; +#X text 134 142 left: MIDI note number; +#X text 135 163 middle: velocity; +#X text 133 187 right: MIDI channel number; +#X obj 34 96 notein; +#X floatatom 35 145 5 0 0; +#X floatatom 52 166 5 0 0; +#X floatatom 72 188 5 0 0; +#X floatatom 42 383 5 0 0; +#X floatatom 91 383 5 0 0; +#X obj 42 350 notein 1; +#X text 105 349 notein listening only to channel 1; +#X text 7 396 note number; +#X text 101 396 velocity; +#N canvas 240 135 478 474 other_midi_objects 0; +#X obj 7 29 ctlin; +#X obj 49 29 pgmin; +#X obj 92 28 bendin; +#X obj 143 27 touchin; +#X obj 204 27 polytouchin; +#X obj 289 27 midiin; +#X obj 340 26 sysexin; +#X obj 6 85 noteout; +#X obj 63 84 ctlout; +#X obj 160 84 bendout; +#X obj 217 83 touchout; +#X obj 281 82 polytouchout; +#X obj 370 82 midiout; +#X obj 113 84 pgmout; +#X obj 11 153 makenote; +#X text 10 194 MIDI notes deconstruction:; +#X text 8 128 MIDI note construction:; +#X text 8 58 MIDI output:; +#X text 8 2 MIDI input:; +#X obj 15 226 stripnote; +#X text 11 266 Additional useful objects for MIDI processing (Maxlib +by Olaf Matthes); +#X obj 148 297 chord; +#X obj 109 296 borax; +#X obj 54 296 score o; +#X obj 13 296 pitch; +#X text 15 336 Also \, from cyclone (alpha) by Krzysztof Czaja:; +#X obj 16 359 midiformat; +#X obj 172 359 midiflush; +#X obj 98 359 midiparse; +#X text 15 386 and xeq \, from the same developer; +#X obj 16 411 xeq; +#X text 41 402 an experimental MIDI sequencer; +#X restore 144 497 pd other_midi_objects; +#X obj 17 497 noteout; +#X obj 13 286 stripnote; +#X text 78 287 is one of the ways to deal with this situation; +#X text 11 41 The [notein] object reads incoming MIDI notes and reports +their note number \, velocity and channel number. Without the argument +it reads from all MIDI channels (omni).; +#X obj 280 526 midi-basics; +#X text 14 526 for an explanation of MIDI usage in PD see:; +#X text 13 312 Arguments: the MIDI channel number from which to read +(with no argument it listens to all channels):; +#X text 80 13 - read incoming stream of MIDI notes.; +#X text 11 207 Note: remember that a 'note-off' is a note with velocity=0. +Therefore [notein] reports each note twice (note-on when a key on your +keyboard is pressed and note-off when the key is released). This could +be sometimes misleading when tracking notes.; +#X text 14 480 related objects; +#X floatatom 44 449 5 0 0; +#X floatatom 93 449 5 0 0; +#X text 9 462 note number; +#X text 103 462 velocity; +#X obj 44 416 notein 17; +#X text 107 415 notein listening only to channel 1 on port 2; +#X text 13 582 This document was created for PD version 0.35 by Michal +Seta as part of a project called pddp proposed by Krzysztof Czaja \, +managed and edited by Dave Sabine \, to build comprehensive documentation +for PD.; +#X connect 6 0 7 0; +#X connect 6 1 8 0; +#X connect 6 2 9 0; +#X connect 12 0 10 0; +#X connect 12 1 11 0; +#X connect 31 0 27 0; +#X connect 31 1 28 0; diff --git a/doc/pddp/help-noteout.pd b/doc/pddp/help-noteout.pd new file mode 100644 index 00000000..43636a3f --- /dev/null +++ b/doc/pddp/help-noteout.pd @@ -0,0 +1,91 @@ +#N canvas 233 2 471 650 10; +#X obj 40 15 noteout; +#X obj 41 343 noteout; +#X obj 287 506 midi-basics; +#X text 18 505 for an explanation of MIDI usage in PD see:; +#X text 13 43 The [noteout] objects writes a note-on MIDI message to +the output port.; +#X text 13 79 inlets:; +#X text 65 106 list - 1st number is interpreted as MIDI note number +\,; +#X text 108 118 the second as velocity and the third (if present); +#X text 110 129 as channel number; +#X text 19 157 right:; +#X text 13 141 middle:; +#X text 66 141 int - velocity; +#X text 21 96 left:; +#X text 64 94 int - MIDI note number (0-127); +#X text 66 155 int - channel number; +#X text 6 175 outlets:; +#X text 65 175 none; +#X text 16 205 Arguments:; +#X text 21 228 MIDI channel number to which a note-on message is to +be sent. If no argument is provided [noteout] transmits on channel +1 (default).; +#X text 12 280 examples:; +#X msg 42 322 60 100 2; +#X text 20 372 (all three above) middle-c with velocity 100 sent to +channel 2; +#X obj 133 343 noteout 2; +#X msg 134 322 60 100; +#X obj 245 287 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X msg 244 326 60; +#X msg 278 324 100; +#X obj 243 305 t b b b; +#X obj 257 345 noteout; +#X msg 308 325 2; +#X text 22 406 See also:; +#X obj 23 427 makenote; +#X text 92 426 -- format a MIDI note (with a note-off message); +#X text 21 452 related object; +#X obj 24 467 notein; +#N canvas 240 135 476 472 other_midi_objects 0; +#X obj 7 29 ctlin; +#X obj 49 29 pgmin; +#X obj 92 28 bendin; +#X obj 143 27 touchin; +#X obj 204 27 polytouchin; +#X obj 289 27 midiin; +#X obj 340 26 sysexin; +#X obj 6 85 noteout; +#X obj 63 84 ctlout; +#X obj 160 84 bendout; +#X obj 217 83 touchout; +#X obj 281 82 polytouchout; +#X obj 370 82 midiout; +#X obj 113 84 pgmout; +#X obj 11 153 makenote; +#X text 10 194 MIDI notes deconstruction:; +#X text 8 128 MIDI note construction:; +#X text 8 58 MIDI output:; +#X text 8 2 MIDI input:; +#X obj 15 226 stripnote; +#X text 11 266 Additional useful objects for MIDI processing (Maxlib +by Olaf Matthes); +#X obj 148 297 chord; +#X obj 109 296 borax; +#X obj 54 296 score o; +#X obj 13 296 pitch; +#X text 15 336 Also \, from cyclone (alpha) by Krzysztof Czaja:; +#X obj 16 359 midiformat; +#X obj 172 359 midiflush; +#X obj 98 359 midiparse; +#X text 15 386 and xeq \, from the same developer; +#X obj 16 411 xeq; +#X text 41 402 an experimental MIDI sequencer; +#X restore 119 467 pd other_midi_objects; +#X text 93 15 - transmit MIDI notes; +#X text 19 543 This document was updated for PD version 0.35 by Michal +Seta as part of a project called pddp proposed by Krzysztof Czaja \, +managed and edited by Dave Sabine \, to build comprehensive documentation +for PD.; +#X connect 20 0 1 0; +#X connect 23 0 22 0; +#X connect 24 0 27 0; +#X connect 25 0 28 0; +#X connect 26 0 28 1; +#X connect 27 0 25 0; +#X connect 27 1 26 0; +#X connect 27 2 29 0; +#X connect 29 0 28 2; diff --git a/doc/pddp/help-operators.pd b/doc/pddp/help-operators.pd new file mode 100644 index 00000000..54742bf9 --- /dev/null +++ b/doc/pddp/help-operators.pd @@ -0,0 +1,283 @@ +#N canvas 23 29 920 640 10; +#X obj 622 350 +~; +#X obj 626 499 trigger; +#X text 25 8 ARITHMETIC; +#X text 30 29 PD's arithmetic objects include:; +#X obj 231 30 +; +#X obj 256 30 -; +#X obj 282 30 *; +#X obj 308 30 /; +#X obj 334 30 pow; +#X obj 359 30 max; +#X obj 385 30 min; +#X obj 32 276 +; +#X floatatom 32 205 0 0 0; +#X floatatom 32 297 0 0 0; +#X floatatom 45 228 0 0 0; +#X msg 63 254 bang; +#X text 98 255 Bang outputs sum; +#X text 70 204 Numbers in left inlet add and output sum; +#X text 87 227 Numbers in right inlet only change the inlet's value +; +#X text 29 171 The example below performs basic addition with two numbers: +i.e. a + b = c; +#X text 28 54 All of these objects operate the same way. The right +inlet sets or changes the numeric value of the object. Sending a number +to the left inlet forces the object to perform the operation with the +current numeric value of the object and output the result. A "bang" +will output the result without changing the numeric values at either +inlet. A creation argument can be used to define the initial numeric +value of the right inlet.; +#X text 29 325 The example below incorporates a creation argument: +i.e. a + 42 = b; +#X floatatom 29 357 0 0 0; +#X floatatom 29 400 0 0 0; +#X obj 29 379 + 42; +#N canvas 38 134 637 241 basic_examples 0; +#X obj 44 129 +; +#X obj 113 129 -; +#X obj 179 129 *; +#X obj 244 129 /; +#X obj 316 129 pow; +#X obj 394 129 max; +#X obj 482 129 min; +#X floatatom 44 32 5 0 0; +#X floatatom 44 150 0 0 0; +#X floatatom 113 149 0 0 0; +#X floatatom 179 149 0 0 0; +#X floatatom 244 149 0 0 0; +#X floatatom 316 149 0 0 0; +#X floatatom 394 150 0 0 0; +#X floatatom 482 149 0 0 0; +#X floatatom 495 32 5 0 0; +#X msg 360 32 bang; +#X connect 0 0 8 0; +#X connect 1 0 9 0; +#X connect 2 0 10 0; +#X connect 3 0 11 0; +#X connect 4 0 12 0; +#X connect 5 0 13 0; +#X connect 6 0 14 0; +#X connect 7 0 0 0; +#X connect 7 0 1 0; +#X connect 7 0 2 0; +#X connect 7 0 3 0; +#X connect 7 0 4 0; +#X connect 7 0 5 0; +#X connect 7 0 6 0; +#X connect 15 0 6 1; +#X connect 15 0 5 1; +#X connect 15 0 4 1; +#X connect 15 0 3 1; +#X connect 15 0 2 1; +#X connect 15 0 1 1; +#X connect 15 0 0 1; +#X connect 16 0 0 0; +#X connect 16 0 1 0; +#X connect 16 0 2 0; +#X connect 16 0 3 0; +#X connect 16 0 4 0; +#X connect 16 0 5 0; +#X connect 16 0 6 0; +#X restore 28 542 pd basic_examples; +#X text 29 425 + - * / are probably self-explanatory...if you are using +PD \, then it is safe to say that you have passed third grade.; +#X text 27 463 However \, [pow] \, [max] \, and [min] objects may need +some explanation.; +#N canvas 0 0 452 302 understanding_POW 0; +#X text 12 25 [POW]; +#X obj 17 66 pow 2; +#X floatatom 17 86 2 0 0; +#X msg 17 46 2; +#X text 61 115 - it is important to note that [pow] only works with +NON-negative mantissas. That is to say that negative floating point +fractions will be ignored.; +#X obj 18 153 pow 2; +#X floatatom 18 173 2 0 0; +#X msg 13 111 -2; +#X msg 24 132 -1.5; +#X text 65 202 - however \, [pow] is capable of computing negative +exponents!; +#X floatatom 19 201 0 0 0; +#X obj 19 221 pow -2; +#X floatatom 19 242 0 0 0; +#X text 57 39 - this object is used to exponentiate a number. The object +returns the value at the left inlet to the power of the right inlet +where the left inlet is the base and the right inlet is the exponent. +For example: 2 to the power of 2 = 4 (i.e. 2 Squared); +#X connect 1 0 2 0; +#X connect 3 0 1 0; +#X connect 5 0 6 0; +#X connect 7 0 5 0; +#X connect 8 0 5 0; +#X connect 10 0 11 0; +#X connect 11 0 12 0; +#X restore 28 497 pd understanding_POW; +#N canvas 0 0 474 341 understanding_MAX_and_MIN 0; +#X text 34 9 [MAX]; +#X obj 32 51 max 10; +#X floatatom 32 29 5 0 0; +#X floatatom 32 76 5 0 0; +#X text 87 26 - [max] returns the greater of the two numbers passed +to its inlets. For example \, if the creation argument (or right inlet) +is equal to 10 \, and you send 9 to the left inlet then the object +will return 10 If you pass it an 11 \, then object returns 11; +#X floatatom 33 116 5 0 0; +#X floatatom 33 163 5 0 0; +#X text 35 96 [MIN]; +#X text 88 113 - [min] returns the lesser of the two numbers passed +to its inlets. For example \, if the creation argument (or right inlet) +is equal to 10 \, and you send 9 to the left inlet then the object +will return 9 If you pass it an 11 \, then object returns 10; +#X obj 33 138 min 10; +#X text 32 185 - It is important to note that [max] and [min] output +a number with every number or "bang" that is sent to the left inlet. +; +#X floatatom 35 234 5 0 0; +#X floatatom 35 282 5 0 0; +#X obj 35 256 min 10; +#X obj 76 281 bng 15 50 10 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 80 232 Move this number box above 10; +#X connect 1 0 3 0; +#X connect 2 0 1 0; +#X connect 5 0 9 0; +#X connect 9 0 6 0; +#X connect 11 0 13 0; +#X connect 13 0 12 0; +#X connect 13 0 14 0; +#X restore 28 519 pd understanding_MAX_and_MIN; +#X obj 430 568 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 430 12 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 469 20 THE SUM OF MANY NUMBERS; +#X text 473 40 PD has wonderful object called [expr] which allows you +to write mathematical expressions. I would suggest that you investigate +the [expr] object to process basic mathematical equations with more +than 2 separate values.; +#X msg 481 151 bang; +#X obj 481 203 random 10; +#X obj 543 203 random 10; +#X obj 605 203 random 10; +#X text 509 222 a; +#X text 571 223 b; +#X text 632 222 c; +#X text 512 288 d; +#X floatatom 481 288 0 0 0; +#X obj 481 172 t b b b; +#X obj 481 245 +; +#X obj 481 266 +; +#X floatatom 481 223 0 0 0; +#X floatatom 543 223 0 0 0; +#X floatatom 605 223 0 0 0; +#X text 474 102 Having said that \, it IS possible to build equations +with multiple elements using these basic math objects \, as in the +example below: (i.e. a + b + c = d); +#X text 469 324 RELATED OBJECTS; +#X obj 651 350 -~; +#X obj 680 350 *~; +#X obj 708 350 /~; +#X obj 736 350 max~; +#X obj 766 350 min~; +#X text 550 350 Audio Math; +#X obj 622 374 ==; +#X obj 680 374 >; +#X obj 736 374 <; +#X obj 708 374 >=; +#X obj 766 373 <=; +#X obj 652 374 !=; +#X text 514 375 Relational Tests; +#X text 508 398 Logical Operators; +#X obj 623 398 &; +#X obj 652 398 |; +#X obj 680 398 &&; +#X obj 708 398 ||; +#X obj 736 398 <<; +#X obj 766 398 >>; +#X obj 680 499 expr; +#X obj 622 422 mtof; +#X obj 653 422 ftom; +#X obj 684 422 powtodb; +#X obj 734 422 rmstodb; +#X obj 784 422 dbtopow; +#X obj 834 422 dbtorms; +#X text 455 423 Acoustical Unit Conversion; +#X text 547 450 Higher Math; +#X obj 793 374 mod; +#X obj 820 374 div; +#X obj 626 449 sin; +#X obj 652 449 cos; +#X obj 679 449 tan; +#X obj 706 449 atan; +#X obj 625 473 atan2; +#X obj 716 499 random; +#X obj 663 473 sqrt; +#X obj 694 473 log; +#X obj 720 473 exp; +#X obj 746 473 abs; +#X text 580 499 Other; +#N canvas 181 122 454 304 related_objects_from_other_libraries 0; +#X obj 37 25 vector+; +#X obj 37 45 vector-; +#X obj 37 65 vector*; +#X obj 85 25 vector/; +#X obj 85 45 rgb2hsv; +#X obj 85 65 hsv2rgb; +#X obj 133 25 abs~; +#X obj 133 45 db2v; +#X obj 133 65 v2db; +#X obj 163 25 avg~; +#X obj 164 45 tavg~; +#X obj 164 65 pdf~; +#X obj 201 24 <~; +#X obj 201 45 ==~; +#X obj 201 67 >~; +#X obj 228 25 &&~; +#X obj 228 46 ||~; +#X obj 228 67 matrix~; +#X obj 280 25 mavg; +#X obj 280 46 mean; +#X obj 280 68 divide; +#X obj 323 27 divmod; +#X obj 324 47 minus; +#X obj 324 67 plus; +#X text 29 104 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 28 153 The best places to find information about PD's libraries +is:; +#X text 25 175 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 27 190 or; +#X text 27 205 iem.kug.ac.at/pdb/; +#X obj 370 27 q8_rsqrt~; +#X obj 370 51 q8_sqrt~; +#X restore 520 537 pd related_objects_from_other_libraries; +#X obj 763 499 f; +#X obj 791 499 int; +#X obj 794 398 %; +#X obj 251 539 timer; +#X text 292 584 This document was updated for PD version 0.35 test +28 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X obj 739 449 pow; +#X connect 11 0 13 0; +#X connect 12 0 11 0; +#X connect 14 0 11 1; +#X connect 15 0 11 0; +#X connect 22 0 24 0; +#X connect 24 0 23 0; +#X connect 31 0 30 0; +#X connect 34 0 43 0; +#X connect 35 0 46 0; +#X connect 36 0 47 0; +#X connect 37 0 48 0; +#X connect 43 0 35 0; +#X connect 43 1 36 0; +#X connect 43 2 37 0; +#X connect 44 0 45 0; +#X connect 45 0 42 0; +#X connect 46 0 44 0; +#X connect 47 0 44 1; +#X connect 48 0 45 1; diff --git a/doc/pddp/help-otherbinops.pd b/doc/pddp/help-otherbinops.pd new file mode 100644 index 00000000..ad1abe8c --- /dev/null +++ b/doc/pddp/help-otherbinops.pd @@ -0,0 +1,435 @@ +#N canvas 16 1 887 655 10; +#X floatatom 217 438 0 0 0; +#X floatatom 267 517 0 0 0; +#X obj 466 28 &; +#X obj 494 28 |; +#X obj 574 28 &&; +#X obj 601 28 ||; +#X obj 7 25 >; +#X obj 36 25 >=; +#X obj 67 24 ==; +#X obj 125 24 <=; +#X obj 153 24 <; +#X obj 217 417 >; +#X obj 267 496 ==; +#X obj 96 24 !=; +#X obj 521 28 <<; +#X obj 548 28 >>; +#X obj 627 28 %; +#X text 464 5 THE LOGICAL OPERATORS -- A.K.A. "Bit Twiddling"; +#X text 6 6 THE RELATIONAL OPERATORS; +#N canvas 0 0 454 304 understanding_%_modulus 0; +#X text 24 23 MODULUS - [%]; +#X floatatom 28 187 0 0 0; +#X text 22 40 - this object has nothing to do with percentage!; +#X text 20 54 - a modulus is a number by which two given numbers can +be divided and produce the same remainder.; +#X text 21 81 - in the example below: 9 / 2 = 4.5 \, and 7 / 2 = 3.5. +Hence if 7 and 9 are divided by 2 \, then the remainder of both equations +is .5. Therefore \, the modulus of 7 and 9 is "2".; +#X msg 28 138 9; +#X obj 28 166 % 7; +#X floatatom 62 142 5 0 0; +#X text 20 222 Note that the modulus operator is not a "bitwise" operator +\, but a math function.; +#X connect 5 0 6 0; +#X connect 6 0 1 0; +#X connect 7 0 6 0; +#X restore 476 418 pd understanding_%_modulus; +#X text 478 252 Below is a brief explanation of each of these logical +operators.; +#X text 473 53 These objects are adopted from the mother of all object +oriented languages: C. They are "bitwise" operators which perform logical +and shift operations on 32-bit numbers.; +#X text 467 100 WHAT DOES "BITWISE" MEAN?; +#X text 478 208 Hence \, performing "bitwise" relational tests means +that PD can compare "1101" to "1001" instead of operating with the +integers that are represented by those binary codes.; +#N canvas 81 197 456 306 understanding_&_AND 0; +#X obj 33 216 &; +#X floatatom 87 182 5 0 0; +#X floatatom 129 183 5 0 0; +#X msg 33 154 13; +#X msg 62 155 9; +#X text 18 18 [&] -- This is the bitwise AND operator which returns +a "1" for each bit position where the corresponding bits of both its +operands are "1". For example:; +#X text 22 67 13 = "1101"; +#X text 28 79 9 = "1001"; +#X text 15 92 Hence:"1001"; +#X obj 33 114 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 33 132 t b b; +#X text 101 66 When comparing the binary codes for 13 and 9 \, we can +see that the first and fourth digits of both codes are 1 Hence the +result will be "1001" -- in other words "9".; +#X floatatom 33 238 0 0 0; +#X connect 0 0 12 0; +#X connect 1 0 0 0; +#X connect 2 0 0 1; +#X connect 3 0 0 0; +#X connect 4 0 0 1; +#X connect 9 0 10 0; +#X connect 10 0 3 0; +#X connect 10 1 4 0; +#X restore 478 286 pd understanding_&_AND; +#N canvas 190 317 454 304 understanding_|_OR 0; +#X floatatom 32 247 0 0 0; +#X floatatom 86 191 5 0 0; +#X floatatom 128 192 5 0 0; +#X msg 32 163 13; +#X msg 61 164 9; +#X text 21 76 13 = "1101"; +#X text 27 88 9 = "1001"; +#X obj 32 123 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 32 141 t b b; +#X text 18 18 [|] -- This is the bitwise OR operator which returns +a "1" for each bit position where one OR both of the corresponding +bits of both its operands is a "1". For example:; +#X text 14 101 Hence:"1101"; +#X text 98 76 When comparing the binary codes for 13 and 9 \, we can +see that the first and fourth digits of both codes are both 1 and the +second position of 13 is a one. Hence the result will be "1101" -- +in other words "13".; +#X obj 32 225 |; +#X connect 1 0 12 0; +#X connect 2 0 12 1; +#X connect 3 0 12 0; +#X connect 4 0 12 1; +#X connect 7 0 8 0; +#X connect 8 0 3 0; +#X connect 8 1 4 0; +#X connect 12 0 0 0; +#X restore 478 307 pd understanding_|_OR; +#N canvas 0 0 454 304 understanding_<<_LEFT-SHIFT 0; +#X obj 46 142 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 46 160 t b b; +#X msg 46 181 13; +#X obj 46 222 <<; +#X floatatom 46 244 5 0 0; +#X msg 74 181 2; +#X floatatom 112 193 5 0 0; +#X floatatom 160 193 5 0 0; +#X text 29 25 [<<] -- This is the left shift operator and it works +by shifting the digits of the binary representation of the first operand +(left inlet) to the left by the number of places specified by the second +operand (right inlet). The spaces created to the right are filled by +zeros \, and any digits falling off the left are discarded. The following +code returns 52 as the binary of 13 ("1101") is shifted two places +to the left giving "110100":; +#X connect 0 0 1 0; +#X connect 1 0 2 0; +#X connect 1 1 5 0; +#X connect 2 0 3 0; +#X connect 3 0 4 0; +#X connect 5 0 3 1; +#X connect 6 0 3 0; +#X connect 7 0 3 1; +#X restore 477 328 pd understanding_<<_LEFT-SHIFT; +#N canvas 0 0 456 380 understanding_>>_RIGHT-SHIFT 0; +#X obj 41 155 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 41 173 t b b; +#X floatatom 41 257 5 0 0; +#X floatatom 107 206 5 0 0; +#X floatatom 155 206 5 0 0; +#X msg 41 194 13; +#X obj 41 235 >>; +#X msg 69 194 2; +#X text 33 21 [>>] -- This is the sign-propagating right shift operator +which shifts the digits of the binary representation of the first operand +(left inlet) to the right by the number of places specified by the +second operand (right inlet) \, discarding any shifted off to the right. +The copies of the leftmost bit are added on from the left \, thereby +preserving the sign of the number. This next examples returns 3 ("11") +as the two right-most bits of 13 ("1101") are shifted off to the right +and discarded.; +#X text 33 284 Note that this object preserves negative values for +negative operands. ("sign-propagating").; +#X connect 0 0 1 0; +#X connect 1 0 5 0; +#X connect 1 1 7 0; +#X connect 3 0 6 0; +#X connect 4 0 6 1; +#X connect 5 0 6 0; +#X connect 6 0 2 0; +#X connect 7 0 6 1; +#X restore 477 350 pd understanding_>>_RIGHT-SHIFT; +#N canvas 56 51 528 425 understanding_&&_LOGICAL-AND 0; +#X msg 56 269 5; +#X obj 25 319 &&; +#X floatatom 25 339 5 0 0; +#X floatatom 194 277 5 0 0; +#X text 12 26 [&&] - This is the logical AND operator \, which returns +a Boolean true (a one) if both operands are true. Logically it follows +that if the first operand is false \, then the whole expression is +false \, and this is how the objects works: It first evaluates the +left hand operand (left inlet) and if this returns false (zero) then +\, without going any further \, it returns a false (a zero). Otherwise +it returns the value of the second operand (right inlet).; +#X floatatom 237 277 5 0 0; +#X text 25 364 Note that this is not a bitwise operator. It compares +floats.; +#X obj 25 227 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 25 245 t b b; +#X msg 25 269 17; +#X text 12 145 In other words \, IF the left inlet is zero \, THEN +output zero. ELSEIF the left inlet is non-zero AND the right inlet +is zero \, then output zero. ELSEIF the left inlet is non-zero AND +the right inlet is non-zero \, THEN output non-zero!; +#X obj 91 227 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 91 245 t b b; +#X msg 91 269 17; +#X msg 122 269 0; +#X connect 0 0 1 1; +#X connect 1 0 2 0; +#X connect 3 0 1 0; +#X connect 5 0 1 1; +#X connect 7 0 8 0; +#X connect 8 0 9 0; +#X connect 8 1 0 0; +#X connect 9 0 1 0; +#X connect 11 0 12 0; +#X connect 12 0 13 0; +#X connect 12 1 14 0; +#X connect 13 0 1 0; +#X connect 14 0 1 1; +#X restore 477 373 pd understanding_&&_LOGICAL-AND; +#N canvas 244 51 530 427 understanding_||_LOGICAL-OR 0; +#X msg 56 269 5; +#X floatatom 25 339 5 0 0; +#X floatatom 196 280 5 0 0; +#X floatatom 239 280 5 0 0; +#X text 25 364 Note that this is not a bitwise operator. It compares +floats.; +#X obj 25 227 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 25 245 t b b; +#X msg 25 269 17; +#X text 17 21 [||] -- This is the logical OR operator and it returns +a value of true (non-zero) if one or both of the operands is true. +It works by first evaluating the left-hand operand (left inlet) and +\, if this is true \, diregarding the right-hand operand (right inlet) +and returning a non-zero. If \, however \, the left-hand operand (left +inlet) is false \, then it returns the value of the right-hand operand +(right inlet).; +#X text 12 145 In other words \, IF the left inlet is non-zero \, THEN +output non-zero. ELSEIF the left inlet is zero AND the right inlet +is zero \, then output zero. ELSEIF the left inlet is zero AND the +right inlet is non-zero \, THEN output non-zero!; +#X obj 25 319 ||; +#X obj 96 226 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 96 244 t b b; +#X msg 96 268 0; +#X msg 127 268 0; +#X connect 0 0 10 1; +#X connect 2 0 10 0; +#X connect 3 0 10 1; +#X connect 5 0 6 0; +#X connect 6 0 7 0; +#X connect 6 1 0 0; +#X connect 7 0 10 0; +#X connect 10 0 1 0; +#X connect 11 0 12 0; +#X connect 12 0 13 0; +#X connect 12 1 14 0; +#X connect 13 0 10 0; +#X connect 14 0 10 1; +#X restore 477 395 pd understanding_||_LOGICAL-OR; +#X obj 432 12 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 432 607 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 54 186 == 42; +#X floatatom 54 165 5 0 0; +#X floatatom 54 212 2 0 0; +#X obj 79 211 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X msg 24 161 42; +#X text 9 143 For example: IF 42 is equal to x \, then "1" (True); +#X text 99 203 Note that the object outputs 1 or 0 with every incoming +message.; +#X text 10 233 All of these objects operate the same way. The right +inlet or creation argument sets the "condition" to which the incoming +messages are compared. The left inlet accepts numbers or a "bang" -- +a number will reset the value and output a true or false (1 or 0) depending +on whether or not the incoming value meets the necessary condition. +A "bang" will force the object to output a true or false (1 or 0) based +on the value that is already stored in the left inlet.; +#X floatatom 25 378 5 0 0; +#X floatatom 98 345 5 0 0; +#X text 10 376 a; +#X text 138 344 b; +#X text 93 439 Is a greater than b?; +#X floatatom 242 478 0 0 0; +#X text 47 478 Is a greater than or equal to b?; +#X obj 242 457 >=; +#X text 166 517 Is a equal to b?; +#X obj 295 534 !=; +#X floatatom 295 554 0 0 0; +#X obj 325 367 r a_b; +#X obj 325 386 unpack f f; +#X obj 25 395 pack f f; +#X obj 25 415 s a_b; +#X obj 98 361 bang; +#X text 172 555 Is a NOT equal to b?; +#X floatatom 321 592 0 0 0; +#X text 215 592 Is a less than b?; +#X obj 321 572 <; +#X floatatom 346 631 0 0 0; +#X obj 346 611 <; +#X text 168 631 Is a less than or equal to b?; +#X text 474 583 This document was updated for PD version 0.35 test +29 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X text 461 460 RELATED OBJECTS; +#X obj 813 477 +; +#X text 480 477 Visit the Help document for MATH for more math objects: +; +#N canvas 0 0 452 302 related_objects_from_other_libraries 0; +#X obj 47 34 strcomp; +#X text 102 33 Relational tests for strings.; +#X text 29 104 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 28 153 The best places to find information about PD's libraries +is:; +#X text 25 175 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 27 190 or; +#X text 27 205 iem.kug.ac.at/pdb/; +#X restore 482 501 pd related_objects_from_other_libraries; +#X text 478 120 Well \, these objects perform "relational" tests on +the binary forms of 32-bit numbers. For example \, the number 13 is +represented in your computer's operating system in binary code by "1101" +and the number 9 is "1001". Each of those binary digits is an 8-bit +word: 8 bits * 4 digits = 32-bits!; +#X obj 179 24 mod; +#X obj 206 24 div; +#X text 8 84 Most relational operators output a boolean value: true +or false (1 or 0) depending on the relation between the input (left +inlet) and the condition (right inlet or creation argument).; +#N canvas 7 1 506 648 understanding_MOD_and_DIV 0; +#X text 24 5 [mod] and [div] are helpful objects to determine whether +or not a fraction produces a remainder \, or to determine the value +of the remainder.; +#X text 24 80 while \, 4 / 3 = 1 with a remainder of 1; +#X text 25 51 For example \, 3 / 3 = 1 with a remainder of zero (i.e. +no remainder).; +#X floatatom 26 190 0 0 0; +#X floatatom 26 232 0 0 0; +#X floatatom 138 192 0 0 0; +#X text 68 191 divided by; +#X text 184 192 has a remainder of; +#X floatatom 300 193 0 0 0; +#X obj 26 211 mod; +#X text 22 103 [mod] takes a number in its left inlet and will divide +that number by either the creation argument or the number given at +its left inlet and will produce the value of the remainder at its outlet. +If no creation argument is given \, then the default value is 1; +#X obj 88 173 loadbang; +#X msg 138 173 1; +#X text 23 255 [div] takes a number in its left inlet and will divide +that number by either the creation argument or the number given at +its left inlet and will produce the result without a remainder. If +no creation argument is given \, then the default value is 1; +#X floatatom 28 341 0 0 0; +#X floatatom 28 383 0 0 0; +#X floatatom 140 343 0 0 0; +#X text 70 342 divided by; +#X floatatom 256 344 0 0 0; +#X obj 90 324 loadbang; +#X msg 140 324 1; +#X obj 28 362 div; +#X text 186 343 is equal to; +#X text 294 343 with no remainder.; +#X obj 257 371 /; +#X floatatom 257 391 0 0 0; +#X text 237 389 or; +#X text 310 392 with a remainder.; +#X text 23 408 In the following example \, I've built a metronome which +counts bar numbers and beat numbers: default time signature is 4/4 +(Common Time).; +#X obj 23 489 metro 500; +#X obj 23 470 tgl 15 0 empty empty Start-Stop 0 -6 0 8 -262144 -1 -1 +0 1; +#X obj 48 510 + 1; +#X floatatom 23 530 0 0 0; +#X text 52 532 Total Beat Count; +#X obj 23 559 div 4; +#X obj 134 560 mod 4; +#X floatatom 219 601 0 0 0; +#X floatatom 108 600 0 0 0; +#X obj 23 510 f 1; +#X msg 107 468 1; +#X obj 23 579 + 1; +#X obj 134 579 + 1; +#X text 131 468 Reset; +#X text 44 599 Bar number; +#X text 157 601 Beat Count; +#X floatatom 339 511 0 0 0; +#X text 196 511 How many beats per bar?; +#X connect 3 0 9 0; +#X connect 4 0 8 0; +#X connect 5 0 9 1; +#X connect 9 0 4 0; +#X connect 11 0 12 0; +#X connect 12 0 5 0; +#X connect 14 0 21 0; +#X connect 14 0 24 0; +#X connect 15 0 18 0; +#X connect 16 0 21 1; +#X connect 16 0 24 1; +#X connect 19 0 20 0; +#X connect 20 0 16 0; +#X connect 21 0 15 0; +#X connect 24 0 25 0; +#X connect 29 0 38 0; +#X connect 30 0 29 0; +#X connect 31 0 38 1; +#X connect 32 0 34 0; +#X connect 32 0 35 0; +#X connect 34 0 40 0; +#X connect 35 0 41 0; +#X connect 38 0 31 0; +#X connect 38 0 32 0; +#X connect 39 0 38 1; +#X connect 40 0 37 0; +#X connect 41 0 36 0; +#X connect 45 0 35 1; +#X connect 45 0 34 1; +#X restore 9 58 pd understanding_MOD_and_DIV; +#X connect 11 0 0 0; +#X connect 12 0 1 0; +#X connect 30 0 31 0; +#X connect 32 0 34 0; +#X connect 32 0 35 0; +#X connect 33 0 32 0; +#X connect 36 0 32 0; +#X connect 40 0 53 0; +#X connect 41 0 53 1; +#X connect 41 0 55 0; +#X connect 47 0 45 0; +#X connect 49 0 50 0; +#X connect 51 0 52 0; +#X connect 52 0 11 0; +#X connect 52 0 47 0; +#X connect 52 0 12 0; +#X connect 52 0 49 0; +#X connect 52 0 59 0; +#X connect 52 0 61 0; +#X connect 52 1 11 1; +#X connect 52 1 47 1; +#X connect 52 1 12 1; +#X connect 52 1 49 1; +#X connect 52 1 59 1; +#X connect 52 1 61 1; +#X connect 53 0 54 0; +#X connect 55 0 40 0; +#X connect 59 0 57 0; +#X connect 61 0 60 0; diff --git a/doc/pddp/help-pack.pd b/doc/pddp/help-pack.pd new file mode 100644 index 00000000..0349f3d2 --- /dev/null +++ b/doc/pddp/help-pack.pd @@ -0,0 +1,128 @@ +#N canvas 13 -7 937 656 10; +#X obj 25 11 pack; +#X text 60 11 - combine several atoms into one message; +#X msg 24 190 bang; +#X obj 24 210 pack 100 0 s 42; +#X text 24 249 In the same example \, this [pack] object will recognize +floats in the first \, second \, and fourth inlet \; it will recognize +symbols in the third inlet. If it receives anything else \, then you'll +see the "no method for ___" error message in the terminal window.; +#X obj 25 366 pack 100 0 s 42; +#X msg 25 328 400 1 cat 38; +#X text 110 328 This works.; +#X msg 37 347 cat dog 42 earth; +#X obj 30 534 pack cat; +#X text 24 419 So \, if [pack] understands that "100" is a float and +can therefore understand all incoming numbers to that inlet...then +you might assume that the word "cat" could be written as a creation +argument and [pack] should understand all incoming symbols. But that's +NOT the case. If you try to define a [pack] symbol with the word "cat" +in a creation argument \, you'll get a "bad type" error.; +#X text 38 516 WRONG; +#X obj 142 538 pack symbol; +#X text 222 528 CORRECT; +#X obj 142 559 print this_package; +#X msg 142 517 cat; +#X text 40 382 Note that the "s" above is an abbreviation for "symbol". +; +#X obj 30 611 pack bang; +#X text 29 578 Same problem with bangs! This [pack] object creates +an error.; +#X obj 416 14 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 416 604 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 448 106 [pack] can be created with any number of creation arguments. +There will be one inlet created for each argument and the values of +each [pack]ed element can be updated at any time using the separate +inlets \; or they can be updated simoultaneously with a LIST of messages +to its first inlet.; +#X text 609 75 is the same as; +#X obj 24 231 print package_1; +#X obj 25 399 print package_2; +#X obj 444 489 print my_package; +#X msg 467 271 1 2 dog; +#X text 518 266 This list doesn't contain enough elements \; so it +resets only the first three elements and then outputs the entire package +- the undefined elements will simply output their previous values. +; +#X obj 444 197 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 476 376 5 0 0; +#X floatatom 474 329 5 0 0; +#X msg 537 423 100 earth me 42; +#X text 548 441 Lists can only be sent to the first inlet -- this list +will cause an error.; +#X text 520 326 A new value for the first element will reset the first +element and force [pack] to output the entire package of stored values. +; +#X text 451 16 Perhaps the best way to build creation arguments is +to define the data types that [pack] should expect at each inlet: (i.e. +floats \, symbols \, or pointers -- or their abbreviations f \, s \, +or p); +#X obj 450 75 pack float symbol pointer; +#X obj 704 76 pack f s p; +#X msg 457 247 42 24 dog cat 1 2; +#X obj 444 469 pack f f s s f f; +#X text 572 247 This list contains new values for each element.; +#X text 19 127 In the example below \, the creation arguments are "100 +\, 0 \, a symbol \, 42". Hence \, when [pack] receives a bang \, it +will send that information to its outlet as a list - or 'package' - +which will be printed in your terminal window.; +#X text 144 348 This doesn't work - the data types; +#X text 143 362 don't correspond with the arguments.; +#X text 17 33 The pack object takes a series of inputs and then outputs +a concatenated list. The number of creation arguments determines the +number of inlets while the type of creation arguments determines the +types of messages that [pack] should expect to receive at each inlet +- although with some peculiarities described below.; +#X text 463 191 Any message to the first inlet will force [pack] to +output its package - its list of values. A bang to the first inlet +will force [pack] to output the current values without resetting any +of them.; +#X text 522 366 This number box will update each of the 'float' values +and will NOT output the package - because the first inlet is not receiving +a message - to change this behavior \, you should explore the [trigger] +object.; +#X text 443 523 RELATED OBJECTS; +#X obj 442 546 trigger; +#X obj 495 546 unpack; +#N canvas 0 0 452 302 related_objects_from_other_libraries 0; +#X obj 21 16 pack~; +#X obj 61 16 unpack~; +#X obj 113 16 tabdump; +#X obj 169 16 niagara; +#X obj 224 16 packel; +#X obj 21 42 repack; +#X obj 70 42 drip; +#X obj 107 42 sort; +#X text 18 86 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 17 135 The best places to find information about PD's libraries +is:; +#X text 14 157 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 15 173 or; +#X text 16 187 iem.kug.ac.at/pdb/; +#X restore 440 571 pd related_objects_from_other_libraries; +#X text 443 601 This document was updated for PD version 0.35 test +26 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X connect 2 0 3 0; +#X connect 3 0 23 0; +#X connect 5 0 24 0; +#X connect 6 0 5 0; +#X connect 8 0 5 0; +#X connect 12 0 14 0; +#X connect 15 0 12 0; +#X connect 19 0 20 0; +#X connect 26 0 38 0; +#X connect 28 0 38 0; +#X connect 29 0 38 1; +#X connect 29 0 38 4; +#X connect 29 0 38 5; +#X connect 30 0 38 0; +#X connect 31 0 38 1; +#X connect 37 0 38 0; +#X connect 38 0 25 0; diff --git a/doc/pddp/help-pgmin.pd b/doc/pddp/help-pgmin.pd new file mode 100644 index 00000000..71ebe3fb --- /dev/null +++ b/doc/pddp/help-pgmin.pd @@ -0,0 +1,67 @@ +#N canvas 290 -2 492 552 10; +#X obj 27 16 pgmin; +#X text 26 47 The [pgmin] object reads incoming program change messages. +; +#X text 26 69 Arguments: (optional) int represents the channel number +to ilsten to. With no argument \, [pgmin] accepts all channels.; +#X text 26 105 Inlets: none. Receives directly from the MIDI port. +; +#X obj 27 142 pgmin; +#X floatatom 27 182 5 0 0; +#X floatatom 57 164 5 0 0; +#X text 101 139 Outlets:; +#X text 119 156 Right - channel number; +#X text 28 308 See also:; +#X obj 29 335 pgmout; +#X obj 26 215 pgmin 2; +#X floatatom 26 237 5 0 0; +#X text 25 258 With one argument (the MIDI channel number) [pgmin] +creates only one outlet (for program change number received). The channel +cannot be changed dynamically.; +#N canvas 240 135 476 472 other_midi_objects 0; +#X obj 7 29 ctlin; +#X obj 49 29 pgmin; +#X obj 92 28 bendin; +#X obj 143 27 touchin; +#X obj 204 27 polytouchin; +#X obj 289 27 midiin; +#X obj 340 26 sysexin; +#X obj 6 85 noteout; +#X obj 63 84 ctlout; +#X obj 160 84 bendout; +#X obj 217 83 touchout; +#X obj 281 82 polytouchout; +#X obj 370 82 midiout; +#X obj 113 84 pgmout; +#X obj 11 153 makenote; +#X text 10 194 MIDI notes deconstruction:; +#X text 8 128 MIDI note construction:; +#X text 8 58 MIDI output:; +#X text 8 2 MIDI input:; +#X obj 15 226 stripnote; +#X text 11 266 Additional useful objects for MIDI processing (Maxlib +by Olaf Matthes); +#X obj 148 297 chord; +#X obj 109 296 borax; +#X obj 54 296 score o; +#X obj 13 296 pitch; +#X text 15 336 Also \, from cyclone (alpha) by Krzysztof Czaja:; +#X obj 16 359 midiformat; +#X obj 172 359 midiflush; +#X obj 98 359 midiparse; +#X text 15 386 and xeq \, from the same developer; +#X obj 16 411 xeq; +#X text 41 402 an experimental MIDI sequencer; +#X restore 105 333 pd other_midi_objects; +#X obj 298 380 midi-basics; +#X text 25 379 for an explanation of MIDI usage in PD see:; +#X text 120 180 Left - program change number; +#X text 66 17 - read incoming program change messages from the MIDI +port; +#X text 22 453 This document was updated for PD version 0.35 by Michal +Seta as part of a project called pddp proposed by Krzysztof Czaja \, +managed and edited by Dave Sabine \, to build comprehensive documentation +for PD.; +#X connect 4 0 5 0; +#X connect 4 1 6 0; +#X connect 11 0 12 0; diff --git a/doc/pddp/help-pgmout.pd b/doc/pddp/help-pgmout.pd new file mode 100644 index 00000000..1498584f --- /dev/null +++ b/doc/pddp/help-pgmout.pd @@ -0,0 +1,68 @@ +#N canvas 293 25 488 486 10; +#X obj 19 12 pgmout; +#X obj 19 134 pgmout; +#X floatatom 19 100 5 0 0; +#X floatatom 55 116 5 0 0; +#X text 93 96 Inlets:; +#X text 105 113 Left: int \, program change value; +#X text 105 135 Right: int \, MIDI channel to send the program change +message on.; +#X obj 25 233 pgmout 2; +#X text 30 289 See also:; +#N canvas 240 135 476 472 other_midi_objects 0; +#X obj 7 29 ctlin; +#X obj 49 29 pgmin; +#X obj 92 28 bendin; +#X obj 143 27 touchin; +#X obj 204 27 polytouchin; +#X obj 289 27 midiin; +#X obj 340 26 sysexin; +#X obj 6 85 noteout; +#X obj 63 84 ctlout; +#X obj 160 84 bendout; +#X obj 217 83 touchout; +#X obj 281 82 polytouchout; +#X obj 370 82 midiout; +#X obj 113 84 pgmout; +#X obj 11 153 makenote; +#X text 10 194 MIDI notes deconstruction:; +#X text 8 128 MIDI note construction:; +#X text 8 58 MIDI output:; +#X text 8 2 MIDI input:; +#X obj 15 226 stripnote; +#X text 11 266 Additional useful objects for MIDI processing (Maxlib +by Olaf Matthes); +#X obj 148 297 chord; +#X obj 109 296 borax; +#X obj 54 296 score o; +#X obj 13 296 pitch; +#X text 15 336 Also \, from cyclone (alpha) by Krzysztof Czaja:; +#X obj 16 359 midiformat; +#X obj 172 359 midiflush; +#X obj 98 359 midiparse; +#X text 15 386 and xeq \, from the same developer; +#X obj 16 411 xeq; +#X text 41 402 an experimental MIDI sequencer; +#X restore 109 316 pd other_midi_objects; +#X obj 295 354 midi-basics; +#X text 25 353 for an explanation of MIDI usage in PD see:; +#X text 92 166 Outlets: None. Sends directly to the MIDI port; +#X floatatom 25 205 5 0 0; +#X obj 31 316 pgmin; +#X text 16 40 Arguments: (optional) and int representing the MIDI channel +to which the program change should be sent. Without an argument it +will send on channel 1 by default.; +#X text 24 262 Send program change message on MIDI channel 2; +#X floatatom 193 205 5 0 0; +#X msg 238 204 2; +#X obj 193 233 pgmout; +#X text 70 12 - send program change messages to the MIDI port; +#X text 23 393 This document was updated for PD version 0.35 by Michal +Seta as part of a project called pddp proposed by Krzysztof Czaja \, +managed and edited by Dave Sabine \, to build comprehensive documentation +for PD.; +#X connect 2 0 1 0; +#X connect 3 0 1 1; +#X connect 13 0 7 0; +#X connect 17 0 19 0; +#X connect 18 0 19 1; diff --git a/doc/pddp/help-pipe.pd b/doc/pddp/help-pipe.pd new file mode 100644 index 00000000..c153a0dc --- /dev/null +++ b/doc/pddp/help-pipe.pd @@ -0,0 +1,117 @@ +#N canvas 1 2 924 627 10; +#X floatatom 435 307 0 0 0; +#X floatatom 432 68 0 0 0; +#X floatatom 432 176 0 0 0; +#X obj 432 94 t f f f; +#X obj 460 125 + 1; +#X obj 488 125 + 2; +#X floatatom 474 175 0 0 0; +#X floatatom 517 176 0 0 0; +#X obj 435 400 pipe 2000; +#X text 474 305 numbers to store and output later; +#X text 500 328 output all stored messages immediately; +#X msg 446 332 flush; +#X msg 463 378 clear; +#X text 511 378 forget all stored messages; +#X obj 436 538 delay; +#X obj 473 538 timer; +#X text 81 13 -- delay a message -- a message "delay line"; +#X obj 49 13 pipe; +#X text 21 40 The Pipe object stores a sequence of messages and outputs +them after a specified delay time in milliseconds. You can change the +delay time as you wish. The outputs are sorted automatically.; +#X text 20 102 BASIC USAGE; +#X text 20 161 Like water running through a pipe \, it goes in one +end...runs the length of the pipe...then comes out the other end.; +#X floatatom 27 206 5 0 0; +#X obj 27 227 pipe 20; +#X floatatom 27 249 5 0 0; +#X text 21 116 The left inlet accepts numbers \, symbols \, pointers +\, messages \, and lists. The right inlet adjusts the delay time (the +length of the pipe).; +#X floatatom 93 210 5 0 0; +#X text 135 209 Adjust the length of the pipe.; +#X text 435 192 METHODS OF CONTROL; +#X text 19 270 Creation arguments can be used to define the data type +to be expected at the left inlet and to define the initial length of +delay.; +#X text 17 314 1 If only one creation argument is used \, it must be +a number and it defines the initial length of delay.; +#X obj 22 345 pipe 1000; +#X text 16 366 2 If a second or third creation argument is used \, +then they will define the data type to be expected at the inlet. Multiple +messages can be sent to [pipe] (similar to [pack] in this case) and +the delay time is the LAST creation argument and can be changed by +the last inlet.; +#X obj 19 468 pipe s 1000; +#X text 92 468 A pipe for symbols.; +#X obj 19 568 pipe f s 1000; +#X text 104 568 A pipe for one float \, and one symbol.; +#X msg 18 438 symbol cat; +#X msg 90 438 symbol dog; +#X symbolatom 19 489 10 0 0; +#X symbolatom 92 589 10 0 0; +#X floatatom 19 589 5 0 0; +#X msg 30 547 100 dog; +#X msg 20 526 42 cat; +#X text 72 523 messages can be sent as lists like this example.; +#X obj 432 151 pipe f f f 1000; +#X text 431 218 [pipe] accepts two very important methods.; +#X text 434 238 1 "flush": forces [pipe] to output all stored messages +immediately.; +#X text 434 267 2 "clear": forces [pipe] to forget all stored messages. +; +#X obj 435 421 print; +#X msg 456 353 bang; +#X text 492 353 output the most recently stored message; +#X text 434 286 3 "bang": repeat the most recently stored message again. +; +#X text 431 443 RESCHEDULING; +#X text 437 458 [pipe] schedules its output immediately after storing +the incoming messages. This means that the delay time can be changed +at runtime without effecting the messages that have already been scheduled +for output.; +#X text 430 11 Miller's original example shows how a list of floats +can be delayed by [pipe]. Note that the [trigger] object is used to +ensure that [pipe] receives the messages from right to left order. +; +#X text 432 518 RELATED OBJECTS; +#N canvas 0 0 454 304 related_objects_from_other_libraries 0; +#X obj 45 31 t3_delay; +#X text 26 77 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 25 126 The best places to find information about PD's libraries +is:; +#X text 22 148 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 24 163 or; +#X text 24 178 iem.kug.ac.at/pdb/; +#X restore 437 561 pd related_objects_from_other_libraries; +#X text 439 579 This document was updated for PD version 0.35 test +28 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X connect 0 0 8 0; +#X connect 1 0 3 0; +#X connect 3 0 44 0; +#X connect 3 1 4 0; +#X connect 3 2 5 0; +#X connect 4 0 44 1; +#X connect 5 0 44 2; +#X connect 8 0 48 0; +#X connect 11 0 8 0; +#X connect 12 0 8 0; +#X connect 21 0 22 0; +#X connect 22 0 23 0; +#X connect 25 0 22 1; +#X connect 32 0 38 0; +#X connect 34 0 40 0; +#X connect 34 1 39 0; +#X connect 36 0 32 0; +#X connect 37 0 32 0; +#X connect 41 0 34 0; +#X connect 42 0 34 0; +#X connect 44 0 2 0; +#X connect 44 1 6 0; +#X connect 44 2 7 0; +#X connect 49 0 8 0; diff --git a/doc/pddp/help-print.pd b/doc/pddp/help-print.pd new file mode 100644 index 00000000..b3d620d5 --- /dev/null +++ b/doc/pddp/help-print.pd @@ -0,0 +1,50 @@ +#N canvas 11 11 777 611 10; +#X msg 93 173 walk the dog; +#X msg 19 173 bang; +#X msg 60 173 234; +#X obj 21 10 print; +#X obj 19 208 print; +#X text 20 44 The print object is used in PD to send messages to the +'terminal window'. When the print object receives a message \, its +output will appear in the terminal window following the name of the +print object and a colon (:). If the print object does not have a name +(which you can supply as an argument within the print object itself) +then the word "print" appears followed by a colon (:) and your message. +; +#X msg 92 240 walk the dog; +#X msg 19 240 bang; +#X msg 59 240 234; +#X obj 19 267 print myPrintObject; +#X text 181 268 A print object with a name.; +#X text 17 309 When the print object receives a list \, it will output +the entire list as a single message. Like below:; +#X obj 17 369 print print_this_list; +#X msg 17 346 10 20 30 foo; +#X msg 17 461 10 20 30 foo; +#X obj 17 514 unpack f f f s; +#X obj 17 547 print unpack_this_list; +#X text 66 201 A print object without a name. Be sure you can see the +terminal window as you click on these messages.; +#X text 74 9 -- print messages to the terminal window; +#X obj 411 43 print~; +#X text 410 22 RELATED OBJECTS; +#X text 17 408 To output the list as separate elements \, the list +needs to be unpacked first. Note that [unpack]'s outlets are triggered +from right to left. Like below:; +#X text 28 481 The arguments here are used to tell PD what type of +atom to expect: (f = float \, s = symbol).; +#X text 402 524 This document was updated for PD version 0.35 test +24 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X connect 0 0 4 0; +#X connect 1 0 4 0; +#X connect 2 0 4 0; +#X connect 6 0 9 0; +#X connect 7 0 9 0; +#X connect 8 0 9 0; +#X connect 13 0 12 0; +#X connect 14 0 15 0; +#X connect 15 0 16 0; +#X connect 15 1 16 0; +#X connect 15 2 16 0; +#X connect 15 3 16 0; diff --git a/doc/pddp/help-random.pd b/doc/pddp/help-random.pd new file mode 100644 index 00000000..cb461562 --- /dev/null +++ b/doc/pddp/help-random.pd @@ -0,0 +1,182 @@ +#N canvas 14 -1 978 651 10; +#X obj 20 11 random; +#X text 70 11 - pseudorandom integer generator; +#X text 20 47 [random] outputs pseudorandom integers between 0 and +N-1 where N is the creation argument or the value of the right inlet. +; +#X obj 28 117 random 100; +#X obj 28 98 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 28 138 3 0 0; +#X text 98 117 Generates random numbers between 0 and 99; +#X obj 28 178 random 100; +#X obj 28 159 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 28 199 3 0 0; +#X floatatom 83 161 5 0 0; +#X text 124 159 Changes the 'range' of random numbers.; +#X text 17 223 SEEDS; +#X text 21 240 Random numbers are generated via a complex equation +which produces a pseudo-predictable sequence of numbers. Each [random] +object's equation is provided with a "seed" which is really just one +of the variables in the equation which produces the sequence. The "seed" +is generated by PD based on specific parameters in each patch which +contains a [random] object. If more than one [random] objects are contained +within a single patch \, they each get a different "seed".; +#X text 21 363 However \, "seeds" can be inputted into [random] by +sending a message \, like below:; +#X msg 13 420 seed 42; +#X obj 67 427 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 67 445 random 1000; +#X floatatom 67 465 3 0 0; +#X obj 13 400 loadbang; +#X text 22 490 Seeds are kept locally so that if two [random]s are +seeded the same \, they will have the same output - as demonstrated +below. Furthermore \, you can seed the same one twice to repeat the +output.; +#X msg 162 556 seed 42; +#X obj 76 559 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 76 591 random 1000; +#X floatatom 76 611 3 0 0; +#X obj 162 536 loadbang; +#X obj 150 591 random 1000; +#X floatatom 150 611 3 0 0; +#X obj 385 12 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 385 620 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 425 18 FERTILE SEEDS!; +#X text 416 39 While the "default" seed for each [random] is usually +very effective \, it may be necessary to find better - more unpredictable +- more indeterminate ways to seed the object to produce a more pleasing +result.; +#X text 415 144 Here are some ideas that may improve the implementation +of [random]:; +#X floatatom 593 241 0 0 0; +#X obj 435 182 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 593 221 / 100; +#X floatatom 435 238 0 0 0; +#X text 455 181 Both methods here produce random numbers between 0 +and 5; +#X obj 593 201 random 501; +#X obj 435 218 random 6; +#X text 660 201 0 - 500; +#X text 631 221 divide by 100 to keep output within range.; +#X text 631 242 produces fractional results between 0 and 5; +#X text 432 269 between 0 and 5; +#X text 432 256 Produces whole numbers; +#X text 401 179 1; +#X text 405 306 2; +#X text 416 94 As well \, there are many ways that [random] can be +incorporated into other structures that change the qualities of the +results.; +#X obj 436 315 loadbang; +#X obj 436 337 timer; +#X obj 518 318 bng 15 250 50 0 empty empty Click_to_seed 0 -6 0 7 -262144 +-1 -1; +#X msg 436 357 seed \$1; +#X obj 497 360 bng 15 250 50 0 empty empty Click_for_output 0 -6 0 +7 -262144 -1 -1; +#X floatatom 497 400 5 0 0; +#X obj 497 379 random 42; +#X text 598 317 "Time is on your side". Using the [timer] object here +(which is started via loadbang) is an interesting trick.; +#X text 407 432 3; +#N canvas 0 0 462 404 weighted_random_numbers 0; +#X msg 38 77 bang; +#X text 24 20 You can generate weighted random numbers from uniformly +distributed ones. If you just want two possible outcomes with a varying +probability for each one \, you can do as shown:; +#X obj 38 103 random 100; +#X obj 37 156 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 104 156 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 140 130 3 0 100; +#X text 185 130 <-- change probablilty; +#X obj 38 131 moses 80; +#X text 87 75 <-- click to test; +#X text 35 184 This outputs a number at left 80% of the time \, otherwise +at right \, unless you override the "80" using the number box. You +may extend this to more than two possible outcomes \, for instance +like this:; +#X msg 42 247 bang; +#X obj 42 273 random 100; +#X obj 42 326 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 132 327 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 91 245 <-- click to test; +#X obj 42 301 moses 10; +#X obj 132 302 moses 30; +#X obj 200 327 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 40 342 10%; +#X text 130 343 20%; +#X text 202 342 70%; +#X connect 0 0 2 0; +#X connect 2 0 7 0; +#X connect 5 0 7 1; +#X connect 7 0 3 0; +#X connect 7 1 4 0; +#X connect 10 0 11 0; +#X connect 11 0 15 0; +#X connect 15 0 12 0; +#X connect 15 1 16 0; +#X connect 16 0 13 0; +#X connect 16 1 17 0; +#X restore 443 432 pd weighted_random_numbers; +#X text 215 556 Click again to repeat output.; +#X text 409 474 RELATED OBJECTS; +#N canvas 0 0 454 304 related_objects_from_other_libraries 0; +#X obj 25 23 randomF; +#X obj 77 23 tripleRand; +#X obj 146 23 shuffle; +#X obj 197 23 mtx_rand; +#X obj 149 47 pin~; +#X obj 25 47 randomblock~; +#X obj 109 47 utime; +#X text 29 104 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 28 153 The best places to find information about PD's libraries +is:; +#X text 25 175 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 27 190 or; +#X text 27 205 iem.kug.ac.at/pdb/; +#X restore 408 494 pd related_objects_from_other_libraries; +#X text 416 592 This document was updated for PD version 0.35 test +29 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X connect 3 0 5 0; +#X connect 4 0 3 0; +#X connect 7 0 9 0; +#X connect 8 0 7 0; +#X connect 10 0 7 1; +#X connect 15 0 17 0; +#X connect 16 0 17 0; +#X connect 17 0 18 0; +#X connect 19 0 15 0; +#X connect 21 0 23 0; +#X connect 21 0 26 0; +#X connect 22 0 23 0; +#X connect 22 0 26 0; +#X connect 23 0 24 0; +#X connect 25 0 21 0; +#X connect 26 0 27 0; +#X connect 28 0 29 0; +#X connect 34 0 38 0; +#X connect 34 0 39 0; +#X connect 35 0 33 0; +#X connect 38 0 35 0; +#X connect 39 0 36 0; +#X connect 48 0 49 0; +#X connect 49 0 51 0; +#X connect 50 0 49 1; +#X connect 51 0 54 0; +#X connect 52 0 54 0; +#X connect 54 0 53 0; diff --git a/doc/pddp/help-realtime.pd b/doc/pddp/help-realtime.pd new file mode 100644 index 00000000..daff3e33 --- /dev/null +++ b/doc/pddp/help-realtime.pd @@ -0,0 +1,108 @@ +#N canvas 64 358 939 645 10; +#X msg 43 113 bang; +#X msg 18 91 bang; +#X floatatom 18 157 0 0 0; +#X text 90 159 Output is in milliseconds; +#X text 53 91 Click here to start or reset; +#X obj 52 545 time_measurements; +#X obj 52 441 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 17 572 0 0 0; +#X floatatom 108 585 0 0 0; +#X floatatom 175 573 0 0 0; +#X text 9 357 In the example below \, I've created an abstraction which +will force each of PD's stop-watches \, [timer] [cputime] and [realtime] +to measure various processes and report the elapsed time. Click on +each [bng] to begin the process and wait for the results. Notice the +discrepancies in the results.; +#X text 15 587 Logical Time; +#X text 173 587 Real Time; +#X text 107 601 CPU Time; +#X obj 67 477 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 72 435 1 Measures elapsed time between two "bangs" from a [trigger] +object.; +#X text 87 469 2 Measures the amount of time PD requires to turn on +DSP and start an oscillator.; +#X obj 445 484 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 445 17 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 472 36 WHY THE DISCREPANCIES BETWEEN CLOCKS?; +#X text 475 59 In a fantasy world \, computers could exist somehow +beyond the restrictions of time and digital computation could be performed +in ZERO time. However \, that is not the case. Instead \, every process +within PD and within your operating system requires at least a few +nanoseconds of your CPU's time.; +#X obj 111 509 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 476 144 The [timer] object is like a clock that is not constrained +to the regular laws of physics and the universal space-time continuum. +It reports "time" measurements as only PD can see them!; +#X text 477 204 The [cputime] object is like a clock that measures +how much time your CPU actually required to carry out your request. +Keep in mind however that your CPU is busy doing many things simoultaneously +\, so even though a process might take 5 minutes to complete \, your +CPU does not pay full attention to that process for the entire 5 minutes. +Instead \, it simply begins the process \, then refers back to that +process from time to time until the it is complete. In other cases +\, your CPU might require a full 5 minutes while PD might report that +merely a few milliseconds have passed. This type of discrepancy depends +heavily on your computer's hardware and the type of processing it is +performing.; +#X text 478 368 The [realtime] object is as much like your own wrist +watch as PD can possibly manage. It measures time according to your +operating system's internal clock.; +#N canvas 0 0 454 304 related_objects_from_other_libraries 0; +#X text 27 63 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 26 112 The best places to find information about PD's libraries +is:; +#X text 23 134 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 25 149 or; +#X text 25 164 iem.kug.ac.at/pdb/; +#X obj 44 24 t3_timer; +#X text 469 589 This document was updated for PD version 0.35 test +26 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X restore 505 476 pd related_objects_from_other_libraries; +#X text 309 580 This document was updated for PD version 0.35 test +28 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X obj 607 445 metro; +#X text 504 422 RELATED OBJECTS; +#X obj 504 446 cputime; +#X text 132 501 3 Measures the amount of time PD requires count to +three...please wait for approximately 3 seconds.; +#X obj 25 15 realtime; +#X text 83 15 -- ask Operating System for elasped real time; +#X text 13 44 The [realtime] object measures elapsed "real" time as +measured by your operating system.; +#X obj 18 135 realtime; +#X text 81 114 Click here to get elapsed real time. Click again...and +again...to see periodic measurements from the start or reset time. +; +#X text 11 185 [realtime] works like essentially like a stop-watch. +Once it starts \, you can continue to "poll" [realtime] to view the +elapsed time.; +#X text 11 232 The odd aspect about comparing [realtime] to a stop-watch +is that a stop-watch can be stopped! [realtime] can only be started +or reset. It cannot be stopped.; +#X text 9 282 As stated above \, [realtime] measures "real" or actual +time. This value may be slightly different that CPU time or "logical" +time. PD offers two objects which measure CPU time and "logical" time. +See the reference documents for those objects for more information. +; +#X obj 562 445 timer; +#X connect 0 0 34 1; +#X connect 1 0 34 0; +#X connect 5 0 7 0; +#X connect 5 1 8 0; +#X connect 5 2 9 0; +#X connect 6 0 5 0; +#X connect 14 0 5 1; +#X connect 18 0 17 0; +#X connect 21 0 5 2; +#X connect 34 0 2 0; diff --git a/doc/pddp/help-receive.pd b/doc/pddp/help-receive.pd new file mode 100644 index 00000000..4e241c29 --- /dev/null +++ b/doc/pddp/help-receive.pd @@ -0,0 +1,11 @@ +#N canvas 62 40 511 244 10; +#X obj 27 10 receive; +#X text 79 12 - receive messages without patch cords.; +#X text 22 63 See; +#X obj 48 63 send; +#X text 79 63 for documentation regarding this object.; +#X text 25 36 This object can be abbreviated as; +#X obj 233 36 r; +#X text 21 95 This document was updated for PD version 0.35 by Dave +Sabine as part of a project called pddp proposed by Krzysztof Czaja +to build comprehensive documentation for PD.; diff --git a/doc/pddp/help-route.pd b/doc/pddp/help-route.pd new file mode 100644 index 00000000..f4f5598a --- /dev/null +++ b/doc/pddp/help-route.pd @@ -0,0 +1,139 @@ +#N canvas 4 7 1003 641 10; +#X obj 7 331 print x1; +#X obj 59 331 print x2; +#X obj 112 331 print x3; +#X obj 164 331 print x4; +#X obj 82 273 route 23 54 1; +#X msg 290 217 54 43; +#X msg 332 217 1 foo bar; +#X obj 44 408 route big apple; +#X msg 422 377 1 2 3; +#X msg 332 364 big apple pie; +#X msg 414 235 walk the dog; +#X text 25 215 numeric arguments:; +#X text 18 364 symbolic arguments:; +#X msg 574 287 bang; +#X msg 575 380 list; +#X msg 547 208 5; +#X msg 553 228 float 5; +#X msg 575 402 list 5; +#X msg 579 307 symbol pie; +#X msg 586 327 pie; +#X msg 561 248 1 2 3; +#X obj 9 475 print y1; +#X obj 69 475 print y2; +#X obj 129 475 print y3; +#X obj 26 13 route; +#X text 67 13 - route messages according to their first element; +#X text 25 108 If a match is found \, and the message contains only +ONE element \, then a bang is sent out the corresponding outlet. If +a match if found \, and the message contains multiple elements (a list) +\, then all the list elements except the first element is sent out +the corresponding outlet. If no match is found \, then the entire message +is sent out the right-most outlet - the "rejection" outlet. The number +of outlets is the number of arguments plus one.; +#X text 176 265 In this case \, the creation arguments are all numbers +and [route] will therefore assume that it should attempt to match messages +that are data type 'number'. All messages that are not numbers will +be output through the right-most outlet.; +#X msg 138 217 23 345 456; +#X msg 216 217 420 34 45; +#X msg 138 364 apple pie; +#X msg 202 364 impeach ringo starr; +#X text 147 408 In this case \, the data type 'symbol' is implied by +the creation arguments and therefore this [route] object will match +symbols only. Symbolic messages that do not match any of the arguments +\, and all numbers \, will be output through the right-most outlet. +; +#X obj 526 5 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 526 566 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 704 468 print NO_Match; +#X text 541 21 If necessary \, messages of different data types can +be matched by the [route] object if the data type is explictly defined +in the creation arguments.; +#X text 540 71 In the example below \, instead of matching the 'value' +of a message \, the [route] object will match 'data type': i.e. lists +will be sent through the first outlet \, floats will be sent through +the second outlet \, symbols through the third outlet \, bangs through +the fourth outlet. The fifth outlet will then output anything that +does not match one of the previously defined data types (i.e. the "pie" +message below is a text message that hasn't been defined as a 'symbol' +- hence \, PD cannot determine which data type it is and it will be +output through the right-most outlet).; +#X text 577 208 a float; +#X text 605 228 definately a float!; +#X text 602 247 a list (of floats); +#X text 611 287 a bang; +#X text 653 306 a symbol; +#X text 620 328 none of the above!; +#X obj 541 448 route float list bang symbol; +#X obj 541 546 print floats; +#X obj 581 527 print lists; +#X obj 622 508 print bangs; +#X obj 663 488 print symbols; +#X msg 575 424 list pie; +#X msg 568 268 list pie earth; +#X text 660 267 a list of symbols; +#X text 595 358 SPECIAL CASES OF LISTS.; +#X text 629 423 A list with only one symbol is translated into a symbol. +; +#X text 621 400 A list with only one float is translated into a float +by PD.; +#X text 612 379 An empty list is tranlated into a bang by PD.; +#X text 19 508 RELATED OBJECTS; +#X obj 23 529 select; +#X obj 68 529 trigger; +#X obj 120 529 moses; +#X text 378 588 This document was updated for PD version 0.35 test +26 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X text 26 36 Route checks the first element of a message against each +of its creation arguments \, which may be numbers or symbols (but not +a mixture of the two unless the data types are defined explicitly) +\, then sends the messages through the appropriate outlets.; +#N canvas 0 0 454 304 related_objects_from_other_libraries 0; +#X obj 26 33 segregate; +#X text 18 86 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 17 135 The best places to find information about PD's libraries +is:; +#X text 14 157 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 15 173 or; +#X text 16 187 iem.kug.ac.at/pdb/; +#X restore 23 552 pd related_objects_from_other_libraries; +#X connect 4 0 0 0; +#X connect 4 1 1 0; +#X connect 4 2 2 0; +#X connect 4 3 3 0; +#X connect 5 0 4 0; +#X connect 6 0 4 0; +#X connect 7 0 21 0; +#X connect 7 1 22 0; +#X connect 7 2 23 0; +#X connect 8 0 7 0; +#X connect 9 0 7 0; +#X connect 10 0 4 0; +#X connect 13 0 44 0; +#X connect 14 0 44 0; +#X connect 15 0 44 0; +#X connect 16 0 44 0; +#X connect 17 0 44 0; +#X connect 18 0 44 0; +#X connect 19 0 44 0; +#X connect 20 0 44 0; +#X connect 28 0 4 0; +#X connect 29 0 4 0; +#X connect 30 0 7 0; +#X connect 31 0 7 0; +#X connect 33 0 34 0; +#X connect 44 0 45 0; +#X connect 44 1 46 0; +#X connect 44 2 47 0; +#X connect 44 3 48 0; +#X connect 44 4 35 0; +#X connect 49 0 44 0; +#X connect 50 0 44 0; diff --git a/doc/pddp/help-select.pd b/doc/pddp/help-select.pd new file mode 100644 index 00000000..8ef0aa4a --- /dev/null +++ b/doc/pddp/help-select.pd @@ -0,0 +1,212 @@ +#N canvas 0 0 1001 659 10; +#X floatatom 19 530 0 0 0; +#X msg 83 488 1; +#X msg 49 488 54; +#X msg 19 488 23; +#X msg 52 126 6; +#X obj 19 165 select 6; +#X msg 19 125 234; +#X floatatom 19 147 0 0 0; +#X obj 19 560 select 23 54 1; +#X obj 46 10 select; +#X text 91 9 - compare numbers or symbols; +#X text 19 38 This object can be abbreviated as; +#X obj 223 39 sel; +#X text 19 55 In its simplest form shown below \, [select] checks its +input agains the constant "6" (which is defined by the creation argument). +If they match \, the first outlet gives "bang" \; otherwise the input +is simply sent through to the second outlet.; +#X obj 19 187 print match; +#X obj 98 187 print NO_match; +#X text 21 217 Note that when the input to [select] matches one of +its creation arguments \, then a "bang" is sent to the outlet \, NOT +the original message.; +#X obj 19 579 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 45 579 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 71 579 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 98 579 5 0 0; +#X text 53 516 If you click-n-drag this number box \, you'll notice +how all numbers except "23" \, "54" \, and "1" are simply sent through +to the rightmost outlet.; +#X text 23 411 Several creation arguments can be defined. In effect +you can use [select] to test the input for many different values. You +will see an outlet for each test value and finally an outlet for values +which match none of them (the rightmost outlet).; +#X obj 635 303 print NO_match; +#X obj 508 302 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 539 303 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 571 303 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 603 303 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X msg 511 92 symbol dog; +#X msg 516 111 symbol cat; +#X msg 524 129 symbol foo; +#X msg 531 149 symbol earth; +#X msg 540 168 symbol 400; +#X obj 508 282 select dog cat foo 400; +#X msg 536 218 400; +#X obj 639 580 print NO_match; +#X obj 512 579 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 543 580 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 575 580 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 607 580 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X msg 508 377 symbol dog; +#X msg 520 404 symbol cat; +#X msg 528 423 symbol foo; +#X msg 535 442 symbol earth; +#X msg 543 463 symbol 400; +#X msg 564 496 400; +#X obj 512 560 select 400 dog cat foo; +#X text 612 160 Notice that "400" here is defined as a symbol data +type and the [select] object can successfully match it to the creation +argment.; +#X text 563 206 Notice that "400" here is a number and the [select] +object cannot successfully match it to the creation argument. That +is because this [select] expects symbols - not numbers.; +#X obj 486 631 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 486 14 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 508 320 However \, in this case below \, you'll notice that +the FIRST creation argument is a number. Therefore \, this [select] +object expects numbers and will ignore the "symbol" data type.; +#X text 547 264 FIRST CREATION ARGUMENT IS A SYMBOL; +#X text 555 543 FIRST CREATION ARGUMENT IS A NUMBER; +#X text 511 9 [select] can also be used to match symbols like the example +in the upper-right of this patch. It important to note that the FIRST +creation argument indicates to the [select] object which data type +to expect. If your first creation argument is a symbol \, like "dog" +\, then the object will test only symbols and numbers will be ignored! +; +#X text 592 490 Notice that "400" here is a number and the [select] +object can successfully match it to the creation argument.; +#X text 612 457 Notice that "400" here is a symbol and the [select] +object cannot successfully match it to the creation argument.; +#X text 21 260 Also note that in the example abovce \, there is a second +inlet. This is used to reset the argument's value like below. This +feature is available only on [select] objects with only ONE creation +argument -- in other example in this patch you'll notice that this +second inlet is absent.; +#X obj 23 373 sel 42; +#X msg 23 330 42; +#X obj 23 392 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 54 392 5 0 0; +#X floatatom 31 349 5 0 0; +#X floatatom 80 351 5 0 0; +#X text 325 686 This document was updated for PD version 0.35 test +24 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X obj 514 645 route; +#X text 513 624 RELATED OBJECTS; +#X text 22 614 A WORD ABOUT CONDITIONAL OBJECTS; +#N canvas 245 41 576 578 more 0; +#X text 22 16 Using the [select] object \, and others listed below +\, PD users can emulate the "conditional" statements of other programming +environments.; +#X text 21 62 Consider the following: (Visual Basic Script); +#X text 60 80 IF input = 1 THEN; +#X text 59 91 response.write("Hello"); +#X text 59 104 ELSEIF input = 2 THEN; +#X text 59 116 response.write("GoodBye"); +#X text 59 130 ELSEIF (input = 3 AND input < 10) THEN; +#X text 59 153 ELSE; +#X text 58 177 END IF; +#X text 23 195 Now the PD equivalent:; +#X msg 37 218 1; +#X msg 67 218 2; +#X floatatom 123 221 5 0 0; +#X obj 37 286 sel 1 2; +#X msg 27 418 symbol Hello; +#X msg 48 388 symbol GoodBye; +#X symbolatom 288 428 20 0 0; +#X obj 33 505 ==; +#X obj 61 505 !=; +#X obj 88 505 >; +#X obj 114 505 <; +#X obj 141 505 >=; +#X obj 168 505 <=; +#X text 28 482 OTHER CONDITIONAL/RELATIONAL OBJECTS IN PD; +#X text 58 164 response.write("No_match_for_me..."& input); +#X text 59 142 response.write("This_is_cool."); +#X obj 74 309 moses 3; +#X msg 84 351 symbol This_is_cool.; +#X obj 111 328 moses 10; +#X obj 220 349 makefilename No_match_for_me...%d; +#X connect 10 0 13 0; +#X connect 11 0 13 0; +#X connect 12 0 13 0; +#X connect 13 0 14 0; +#X connect 13 1 15 0; +#X connect 13 2 26 0; +#X connect 14 0 16 0; +#X connect 15 0 16 0; +#X connect 26 1 28 0; +#X connect 27 0 16 0; +#X connect 28 0 27 0; +#X connect 28 1 29 0; +#X connect 29 0 16 0; +#X restore 24 632 pd more; +#N canvas 0 0 452 302 related_objects_from_other_libraries 0; +#X obj 28 15 multiselect; +#X text 19 53 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 18 102 The best places to find information about PD's libraries +is:; +#X text 15 124 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 16 140 or; +#X text 17 154 iem.kug.ac.at/pdb/; +#X restore 554 644 pd related_objects_from_other_libraries; +#X connect 0 0 8 0; +#X connect 1 0 0 0; +#X connect 2 0 0 0; +#X connect 3 0 0 0; +#X connect 4 0 7 0; +#X connect 5 0 14 0; +#X connect 5 1 15 0; +#X connect 6 0 7 0; +#X connect 7 0 5 0; +#X connect 8 0 17 0; +#X connect 8 1 18 0; +#X connect 8 2 19 0; +#X connect 8 3 20 0; +#X connect 28 0 33 0; +#X connect 29 0 33 0; +#X connect 30 0 33 0; +#X connect 31 0 33 0; +#X connect 32 0 33 0; +#X connect 33 0 24 0; +#X connect 33 1 25 0; +#X connect 33 2 26 0; +#X connect 33 3 27 0; +#X connect 33 4 23 0; +#X connect 34 0 33 0; +#X connect 40 0 46 0; +#X connect 41 0 46 0; +#X connect 42 0 46 0; +#X connect 43 0 46 0; +#X connect 44 0 46 0; +#X connect 45 0 46 0; +#X connect 46 0 36 0; +#X connect 46 1 37 0; +#X connect 46 2 38 0; +#X connect 46 3 39 0; +#X connect 46 4 35 0; +#X connect 50 0 49 0; +#X connect 58 0 60 0; +#X connect 58 1 61 0; +#X connect 59 0 58 0; +#X connect 62 0 58 0; +#X connect 63 0 58 1; diff --git a/doc/pddp/help-send.pd b/doc/pddp/help-send.pd new file mode 100644 index 00000000..f8d8bc92 --- /dev/null +++ b/doc/pddp/help-send.pd @@ -0,0 +1,199 @@ +#N canvas -7 -1 1011 660 10; +#X obj 25 11 send; +#X text 58 12 - sends messages without patch cords.; +#X text 481 26 At this point \, it is necessary to explain 'locality' +and 'scope'. When creating a [send] and/or [receive] object it is helpful +to determine whether or not the messages you pass through those objects +will be used by only ONE patch \, or throughout all open patches.; +#X obj 229 34 s; +#X text 23 35 This object can be abbreviated as; +#X text 23 158 Send and recevie objects are given a name to tell them +who to connect to. Here is a simple example of how these objects work +together:; +#X text 25 60 The [send] object \, and its counterpart \, [receive] +\, are useful for linking objects and subroutines together in a single +canvas or throughout multiple patches. Understanding these objects +will help 'clean up' your patches and allow you to communicate messages +between various modules that you build or between objects where patch +cords are not possible.; +#X floatatom 246 223 5 0 0; +#X floatatom 26 205 5 0 0; +#X text 67 205 Click-n-drag this number box.; +#X obj 26 222 send this_number; +#X obj 246 204 receive this_number; +#X obj 26 293 send this_symbol; +#X obj 245 279 receive this_symbol; +#X symbolatom 245 297 15 0 0; +#X msg 26 252 symbol dog; +#X msg 40 272 symbol cat; +#X text 101 253 Click these messages.; +#X text 23 323 Also note that you can send messages to a receive object +by providing the name of the receive object and your message in a message +box \, like below: (watch the receive object ABOVE); +#X msg 27 385 \; this_number 20 \; this_symbol symbol foo \;; +#X msg 230 384 \; this_number 4000 \; this_symbol symbol hello_world +\;; +#X msg 27 435 \; this_number 42 \;; +#X msg 230 434 \; this_symbol symbol Jupiter \;; +#X obj 436 5 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 436 581 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 473 10 IMPORTANT; +#N canvas 0 0 248 163 example_a 0; +#X obj 18 9 r foo; +#X floatatom 18 34 5 0 0; +#X obj 24 96 r a-foo; +#X floatatom 24 116 5 0 0; +#X connect 0 0 1 0; +#X connect 2 0 3 0; +#X restore 561 139 pd example_a; +#N canvas 2 238 250 157 example_b 0; +#X obj 12 9 r foo; +#X floatatom 12 28 5 0 0; +#X obj 15 74 r b-foo; +#X floatatom 15 93 5 0 0; +#X connect 0 0 1 0; +#X connect 2 0 3 0; +#X restore 642 140 pd example_b; +#N canvas -1 473 225 163 example_c 0; +#X obj 12 8 r foo; +#X floatatom 12 30 5 0 0; +#X obj 12 65 r c-foo; +#X floatatom 12 86 5 0 0; +#X connect 0 0 1 0; +#X connect 2 0 3 0; +#X restore 724 140 pd example_c; +#X obj 480 240 s foo; +#X floatatom 480 224 5 0 0; +#X text 478 196 Click-n-drag these number boxes and notice the appropriate +receive objects in each open sub-patch.; +#X floatatom 525 224 5 0 0; +#X floatatom 581 225 5 0 0; +#X floatatom 639 225 5 0 0; +#X obj 525 240 s a-foo; +#X obj 581 241 s b-foo; +#X obj 639 241 s c-foo; +#X text 475 166 TO SEND MESSAGES TO ALL RECEIVES OF THE SAME NAME IN +ALL OPEN PATCHES - global scope.; +#X text 482 95 To observe these features \, click on the following +sub-patches to open each one on your screen. Move them all so that +you can see each one clearly and also see this main patch.; +#X text 470 397 TO SEND MESSAGES TO RECEIVE OBJECTS WITHIN A SINGLE +PATCH - local scope.; +#X text 480 426 There are many cases where you may want messages to +be sent within a single patch. For example \, you might have designed +many modules with a receive object called [r number] but you want that +'number' to be passed to only the objects within a single module so +that they don't effect the performance of the other modules.; +#X text 481 506 In these cases \, you should use "local variables" +to name your send and receive objects. Local variables are assigned +using dollar signs and numbers. There is more documentation about this +in 2.control.examples/locality.pd; +#X text 23 550 RELATED OBJECTS; +#X obj 86 574 send~; +#X obj 123 574 receive~; +#X obj 179 574 netsend; +#X obj 228 574 netreceive; +#X obj 24 574 receive; +#X obj 23 596 tabsend~; +#X text 477 262 Send objects simply post their information to the cyberspace +within your computer (that's one way to look at it!) Receive objects +simply keep their ears open for all messages floating through that +cyberspace from send objects of the same name! Hence \, if you name +a [send] something like "foo" \, then all [receive] objects in open +patches named "foo" will 'hear' those messages. Also note that the +term 'open patches' includes all sub-patches \, abstractions and patches +that are currently open in PD - they don't have to be VISIBLE...they +only have to be active.; +#X text 481 585 This document was updated for PD version 0.35 by Dave +Sabine as part of a project called pddp proposed by Krzysztof Czaja +to build comprehensive documentation for PD.; +#X text 21 478 SPECIAL OBJECTS AND THEIR PROPERTIES; +#X text 27 492 Some objects in PD contain their own internal send and +receive functionality. Open the following sub-patch for more information: +; +#N canvas 129 123 768 452 special-send-and-receives 0; +#X text 26 18 SPECIAL OBJECTS; +#X obj 28 41 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 28 66 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 1 +; +#X obj 28 91 nbx 5 14 -1e+037 1e+037 0 0 empty empty empty 0 -6 0 10 +-262144 -1 -1 0 256; +#X obj 28 117 vsl 15 128 0 127 0 0 empty empty empty 0 -8 0 8 -262144 +-1 -1 0 1; +#X obj 21 368 hdl 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1 -1 +0; +#X obj 159 129 vdl 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1 -1 +0; +#X obj 24 343 hsl 128 15 0 127 0 0 empty empty empty -2 -6 0 8 -262144 +-1 -1 0 1; +#X obj 79 208 vu 15 120 empty empty -1 -8 0 8 -66577 -1 1 0; +#X obj 192 31 cnv 15 100 60 empty empty empty 20 12 0 14 -233017 -66577 +0; +#X text 54 41 bng; +#X text 51 66 toggle; +#X text 93 90 number 2; +#X text 48 168 Vertical Slider; +#X text 185 167 Vertical Dial; +#X text 164 344 Horizontal Slider; +#X text 154 368 Horizontal Dial; +#X text 136 261 VU Meter; +#X text 225 55 canvas; +#X text 331 28 The objects in this patch \, and likely many more which +I have not included \, include their own send and receive functionality. +This functionality can be accessed by right-clicking on the object +and choosing "Properties" from the menu that appears.; +#X text 328 101 EXAMPLE; +#X text 333 117 In other words \, these objects can send and/or receive +messages without attaching a separate [send] or [receive] object to +them with a patch cord.; +#X text 328 161 THE OL'FASHION WAY; +#X floatatom 330 182 5 0 0; +#X floatatom 375 200 5 0 0; +#X obj 330 199 s a; +#X obj 375 181 r a; +#X text 330 222 USING THESE OBJECTS' INTERNAL SEND AND RECEIVE FUNCTIONALITY +; +#X text 422 181 As you see here \, these number boxes are linked together +with send and receives objects.; +#X obj 332 244 nbx 5 14 -1e+037 1e+037 0 0 b empty empty 0 -6 128 10 +-262144 -1 -1 0 256; +#X obj 394 244 nbx 5 14 -1e+037 1e+037 0 0 empty b empty 0 -6 64 10 +-262144 -1 -1 0 256; +#X text 334 262 These number boxes are linked together via their 'send' +or 'receive' property.; +#X connect 23 0 25 0; +#X connect 26 0 24 0; +#X restore 136 523 pd special-send-and-receives; +#N canvas 0 0 439 206 related_objects_from_other_libraries 0; +#X text 17 52 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 16 101 The best places to find information about PD's libraries +is:; +#X text 13 123 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 15 138 or; +#X text 15 153 iem.kug.ac.at/pdb/; +#X obj 16 22 streamout~; +#X obj 82 22 sendlocal; +#X obj 144 22 system; +#X obj 186 22 shoutcast~; +#X obj 254 22 sendOSC; +#X obj 304 22 send13~; +#X restore 172 596 pd related_objects_from_other_libraries; +#X obj 76 596 throw~; +#X obj 118 596 catch~; +#X obj 297 574 value; +#X connect 8 0 10 0; +#X connect 11 0 7 0; +#X connect 13 0 14 0; +#X connect 15 0 12 0; +#X connect 16 0 12 0; +#X connect 23 0 24 0; +#X connect 30 0 29 0; +#X connect 32 0 35 0; +#X connect 33 0 36 0; +#X connect 34 0 37 0; diff --git a/doc/pddp/help-spigot.pd b/doc/pddp/help-spigot.pd new file mode 100644 index 00000000..03629bdf --- /dev/null +++ b/doc/pddp/help-spigot.pd @@ -0,0 +1,119 @@ +#N canvas 94 12 862 647 10; +#X msg 16 96 0.5 1000; +#X floatatom 47 160 1 0 0; +#X obj 16 177 spigot; +#X obj 16 198 print; +#X msg 28 136 walk the cat; +#X msg 22 116 bang; +#X obj 35 11 spigot; +#X text 83 11 - pass or block messages; +#X text 72 160 control: nonzero to pass messages \, zero to stop them +; +#X text 12 294 USING [SPIGOT] TO CREATE A GATE.; +#X text 15 309 Unlike its closest cousin MAX \, PD does not have a +native [gate] object. There are other PD libraries which include gates +for both audio and numerical data \, but similar routines can be built +in PD using [spigot]. The example below shows a two-way gate using +two [spigots] and the [expr] object.; +#X obj 95 505 spigot; +#X floatatom 96 459 1 0 0; +#X text 113 458 controls: open and close the gates.; +#X floatatom 31 527 5 0 0; +#X floatatom 95 527 5 0 0; +#X obj 15 400 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 1 +; +#X obj 15 418 metro 200; +#X obj 15 439 f; +#X obj 39 439 + 1; +#X obj 126 484 expr 1-$f1; +#X text 32 398 Click to start sending info through the gates.; +#X obj 96 439 loadbang; +#X text 16 38 [spigot] passes messages from its left inlet to its outlet +\, as long as a nonzero number is sent to its right inlet. When its +right inlet gets zero \, incoming messages are "blocked" (i.e. ignored). +; +#X text 14 231 [spigot] works essentially like a doorway. When the +door is open \, messages can pass through. When the door is closed +\, messages are ignored. By default \, the door is always closed!; +#X obj 31 505 spigot; +#X text 13 547 In the example above \, the magic is created by the +[expr] object which performs a simple calculation using the incoming +number (1 or 0). Note that the figure "$f1" is a variable which assumes +the value of the incoming number.; +#X text 402 36 CREATION ARGUMENTS?; +#X obj 416 98 spigot 0; +#X text 404 196 [SPIGOT] FOR AUDIO SIGNALS?; +#X text 417 213 [spigot] does not work with audio signals. The data +types which are accepted by this object are floats \, symbols \, lists +\, bangs \, anythings and pointers. However \, audio signals require +a completely different treatment.; +#X text 414 265 PD does not have a [spigot] for audio signals \, but +the same effect can be created using the following structure:; +#X obj 418 312 osc~ 800; +#X obj 386 15 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 386 596 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 418 369 *~; +#X floatatom 431 352 1 0 0; +#X obj 400 447 env~; +#X floatatom 400 468 5 0 0; +#X msg 628 341 \; pd dsp \$1 \;; +#X obj 628 322 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 +1; +#X obj 445 466 dac~; +#X obj 445 446 *~ 0.05; +#X text 645 323 Turn on audio computation first.; +#X text 449 357 Here is the [spigot].; +#X text 448 370 When "0" \, audio signal; +#X text 447 386 is effectively blocked.; +#X text 448 400 When "1" \, audio signal is; +#X text 448 415 not effected in any way.; +#X text 406 498 RELATED OBJECTS; +#N canvas 0 0 454 304 related_objects_from_other_libraries 0; +#X obj 40 36 gate; +#X text 18 86 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 17 135 The best places to find information about PD's libraries +is:; +#X text 14 157 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 15 173 or; +#X text 16 187 iem.kug.ac.at/pdb/; +#X restore 419 519 pd related_objects_from_other_libraries; +#X text 453 574 This document was updated for PD version 0.35 test +26 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X obj 416 170 spigot cat; +#X obj 490 170 spigot dog; +#X text 415 119 It also accepts any symbol \, but all of these are +meaningless and have no effect on the operation of the object.; +#X text 416 54 [spigot] only accepts one numerical creation argument: +a zero. At creation time the [spigot] is "closed". So this creation +argument is not needed and is rather useless.; +#X connect 0 0 2 0; +#X connect 1 0 2 1; +#X connect 2 0 3 0; +#X connect 4 0 2 0; +#X connect 5 0 2 0; +#X connect 11 0 15 0; +#X connect 12 0 20 0; +#X connect 12 0 25 1; +#X connect 16 0 17 0; +#X connect 17 0 18 0; +#X connect 18 0 19 0; +#X connect 18 0 11 0; +#X connect 18 0 25 0; +#X connect 19 0 18 1; +#X connect 20 0 11 1; +#X connect 22 0 12 0; +#X connect 25 0 14 0; +#X connect 32 0 35 0; +#X connect 33 0 34 0; +#X connect 35 0 37 0; +#X connect 35 0 42 0; +#X connect 36 0 35 1; +#X connect 37 0 38 0; +#X connect 40 0 39 0; +#X connect 42 0 41 0; diff --git a/doc/pddp/help-swap.pd b/doc/pddp/help-swap.pd new file mode 100644 index 00000000..5b966254 --- /dev/null +++ b/doc/pddp/help-swap.pd @@ -0,0 +1,185 @@ +#N canvas 0 0 625 631 12; +#X obj 104 572 pddp; +#X obj 8 8 cnv 15 90 586 empty empty empty 20 12 0 14 -233017 -66577 +0; +#X text 37 47 INLETS:; +#X obj 54 18 swap; +#X text 108 18 - SWAP TWO NUMBERS \, RESPECTING RIGHT-TO-LEFT ORDER +; +#X obj 285 470 swap; +#X floatatom 175 429 5 0 0 0 - - -; +#X floatatom 372 437 5 0 0 0 - - -; +#X floatatom 312 497 5 0 0 0 - - -; +#X floatatom 263 497 5 0 0 0 - - -; +#X msg 243 427 42 7; +#X obj 119 438 bng 15 250 50 0 empty empty "bang" 0 -6 0 8 -262144 +-1 -1; +#X msg 290 415 42 7 3 4; +#X floatatom 506 491 5 0 0 0 - - -; +#X floatatom 454 490 5 0 0 0 - - -; +#X msg 454 436 bang; +#X obj 454 460 swap 12; +#X text 37 62 - LEFT:; +#X text 28 263 - RIGHT:; +#X text 104 63 Float - A float at the left inlet will send the number +to the right outlet and then send the number at the right inlet to +the left outlet.; +#X text 104 117 Bang - A bang at the left inlet will force [swap] to +send its values to the outlets \, in reverse order. The value from +the left inlet will be sent to the right outlet then the value at the +right inlet will be sent out the left outlet.; +#X text 104 188 List - A list at the left inlet will update the values +of both of [swap]'s inlets and send the numbers to the outlets in reverse +order. Note that lists of 3 or more elements will be truncated.; +#X text 104 264 Float - A float at the right inlet is stored for later +use. It will be sent to the left outlet when a float or bang is received +in the left inlet.; +#X text 104 317 One - [swap] accepts a single float as a creation argument +which initializes the first value to be sent out the left outlet.; +#X text 104 370 Two - outputs the float values of the two inlets in +reverse order when a float \, list \, or bang is received at the left +inlet.; +#X text 371 418 float; +#X text 174 410 float; +#X text 244 409 list; +#X text 428 510 creation argument; +#N canvas 59 0 397 246 Related_Objects 0; +#X text 25 11 Native PD Objects; +#X text 23 92 Externals and other object libraries; +#X obj 42 48 pack; +#X obj 104 48 unpack; +#X text 30 126 [split]; +#X restore 104 522 pd Related_Objects; +#N canvas 60 0 581 620 More_Info 0; +#X msg 38 54 42 7; +#X obj 38 79 swap; +#X floatatom 38 105 5 0 0 0 - - -; +#X floatatom 97 105 5 0 0 0 - - -; +#X obj 38 129 pack f f; +#X obj 38 153 print; +#N canvas 154 0 649 595 millers_note-off_parser 0; +#X obj 27 18 notein; +#X text 103 14 [notein] is an object which receives incoming MIDI data +from a MIDI instrument. The three outlets are PITCH \, VELOCITY \, +and MIDI CHANNEL from left to right. It is important to note however +that the data is outputted from right to left. Which means that the +first piece of information to be sent out the object is the MIDI CHANNEL. +; +#X obj 26 117 swap; +#X obj 26 156 pack; +#X obj 26 200 route 0; +#X floatatom 26 228 5 0 0 0 - - -; +#X text 102 117 Here \, [swap] is used to store the VELOCITY until +the PITCH information comes from [notein]. The next step will pack +the two together...but we have to ensure that [pack] receives the two +numbers in the correct order: PITCH first \, then VELOCITY. This way +\, using [route] we can determine whether or not this incoming MIDI +data is a "note-off" signal (i.e. VELOCITY = 0).; +#X obj 26 250 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 46 312 notein; +#X obj 47 352 pack; +#X obj 47 377 route 0; +#X floatatom 47 402 5 0 0 0 - - -; +#X obj 47 420 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 122 308 The goal of the Miller's example at the bottom left +\, is to retrieve "note-off" signals from [notein]. To do that \, we +have to test the incoming data for pitches with a velocity of zero. +To do that \, we are packing up the incoming PITCH and VELOCITY data +and sending them to [route]...in effect we achieve the following:; +#X text 98 420 IF velocity = 0 THEN "bang"; +#X text 127 445 In the example above \, the [pack] object will output +a list as soon as the VELOCITY information comes from [notein]. As +a result \, the list will be outputted from pack BEFORE the PITCH information +is retrieved. [swap] is used to solve this problem by making sure that +the VELOCITY and PITCH are both received before packing them up and +sending them to the [route] object.; +#X text 50 248 This will "bang" only when velocity = 0; +#X text 22 282 THIS IS WHY THE ALTERNATIVE DOESN'T WORK?; +#X connect 0 0 2 0; +#X connect 0 1 2 1; +#X connect 2 0 3 0; +#X connect 2 1 3 1; +#X connect 3 0 4 0; +#X connect 4 0 5 0; +#X connect 5 0 7 0; +#X connect 8 0 9 1; +#X connect 8 1 9 0; +#X connect 9 0 10 0; +#X connect 10 0 11 0; +#X connect 11 0 12 0; +#X restore 28 569 pd millers_note-off_parser; +#X floatatom 44 319 5 0 0 0 - - -; +#X floatatom 94 319 5 0 0 0 - - -; +#X floatatom 143 319 5 0 0 0 - - -; +#X floatatom 112 440 5 0 0 0 - - -; +#X floatatom 161 440 5 0 0 0 - - -; +#X floatatom 211 440 5 0 0 0 - - -; +#X msg 37 243 2 2500 9 420; +#X obj 43 289 unpack f f f f; +#X floatatom 193 319 5 0 0 0 - - -; +#X text 14 10 [swap] is most commonly used to change the order of a +list. This trick is best suited for a PAIR of numbers.; +#X obj 166 345 swap; +#X obj 139 370 swap; +#X obj 112 394 swap; +#X obj 196 378 swap; +#X obj 169 403 swap; +#X obj 228 408 swap; +#X floatatom 262 440 5 0 0 0 - - -; +#X text 230 345 This could quickly become ridiculous!; +#X msg 165 245 1 2 3 4; +#X msg 254 258 0 200 3333 1111; +#X text 14 477 In other settings \, the [swap] object is useful as +a timing mechanism to ensure that two numbers arrive at their destination +in a particular order. Miller Puckette provided an excellent example +of [swap] used to build a 'note-off parser'.; +#X text 14 185 Lists that are longer than two elements could be sorted +this way \, but the structure quickly becomes unmanageable. It's probably +better to find an alternative method.; +#X connect 0 0 1 0; +#X connect 1 0 2 0; +#X connect 1 1 3 0; +#X connect 2 0 4 0; +#X connect 3 0 4 1; +#X connect 4 0 5 0; +#X connect 7 0 19 0; +#X connect 8 0 18 0; +#X connect 9 0 17 0; +#X connect 13 0 14 0; +#X connect 14 0 7 0; +#X connect 14 1 8 0; +#X connect 14 2 9 0; +#X connect 14 3 15 0; +#X connect 15 0 17 1; +#X connect 17 0 18 1; +#X connect 17 1 20 1; +#X connect 18 0 19 1; +#X connect 18 1 20 0; +#X connect 19 0 10 0; +#X connect 19 1 21 0; +#X connect 20 0 21 1; +#X connect 20 1 22 1; +#X connect 21 0 11 0; +#X connect 21 1 22 0; +#X connect 22 0 12 0; +#X connect 22 1 23 0; +#X connect 25 0 14 0; +#X connect 26 0 14 0; +#X restore 104 547 pd More_Info; +#X text 152 573 - Dave Sabine \, November 12 \, 2002; +#X text 13 317 ARGUMENTS:; +#X text 29 369 OUTLETS:; +#X text 20 427 EXAMPLES:; +#X text 21 522 SEE ALSO:; +#X connect 5 0 9 0; +#X connect 5 1 8 0; +#X connect 6 0 5 0; +#X connect 7 0 5 1; +#X connect 10 0 5 0; +#X connect 11 0 5 0; +#X connect 12 0 5 0; +#X connect 15 0 16 0; +#X connect 16 0 14 0; +#X connect 16 1 13 0; diff --git a/doc/pddp/help-symbol.pd b/doc/pddp/help-symbol.pd new file mode 100644 index 00000000..474f01af --- /dev/null +++ b/doc/pddp/help-symbol.pd @@ -0,0 +1,67 @@ +#N canvas 15 6 542 640 10; +#X text 31 576 This document was updated for PD version 0.35 test 24 +by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X obj 55 12 symbol; +#X text 98 13 - STORE A SYMBOL; +#X obj 28 259 symbol; +#X msg 28 112 bang; +#X text 60 112 "Bang" will force the object to output its value.; +#X symbolatom 28 314 10 0 0; +#X obj 28 333 print; +#X text 22 41 The symbol object stores a symbol (which is set either +by its creation argument or by the right inlet) and then outputs that +symbol when it receives a "bang" message or a new symbol in its left +inlet.; +#X text 26 394 IMPORTANT NOTE; +#X obj 165 414 symbol; +#X symbolatom 290 429 10 0 0; +#X text 32 447 Please do not get them confused.; +#X text 75 332 For this example \, I have used the symbol atom to display +the value that was stored in the symbol object and also printed the +value to the terminal window.; +#X text 74 253 The symbols are stored here. When banged \, the symbol +is outputted through the outlet. Note that a creation argument is optional. +; +#X msg 40 137 dog; +#X msg 48 155 cat; +#X msg 59 181 symbol horse; +#X msg 73 199 symbol wolf; +#X msg 82 217 symbol pig; +#X text 75 139 Sending a symbol to its left inlet will store AND output +the value.; +#X text 24 487 RELATED OBJECTS; +#X obj 26 513 int; +#X obj 52 513 float; +#X obj 89 513 f; +#X obj 115 513 select; +#X obj 164 513 makefilename; +#X text 153 179 Sending new symbols to its right inlet will store the +values. These values can later be sent via "bang" to its left inlet. +Note that these symbols are preceded by the word "symbol" to indicate +the appropriate data type.; +#X text 31 414 Symbol - the OBJECT -; +#X text 31 429 is very different than symbol - the ATOM -; +#N canvas 0 0 454 230 related_objects_from_other_libraries 0; +#X obj 150 28 makesymbol; +#X obj 110 29 index; +#X obj 16 27 ftos; +#X obj 52 28 unsymbol; +#X text 17 58 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 16 107 The best places to find information about PD's libraries +is:; +#X text 13 129 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 14 145 or; +#X text 15 159 iem.kug.ac.at/pdb/; +#X restore 25 536 pd related_objects_from_other_libraries; +#X connect 3 0 6 0; +#X connect 4 0 3 0; +#X connect 6 0 7 0; +#X connect 15 0 3 0; +#X connect 16 0 3 0; +#X connect 17 0 3 1; +#X connect 18 0 3 1; +#X connect 19 0 3 1; diff --git a/doc/pddp/help-tabread.pd b/doc/pddp/help-tabread.pd new file mode 100644 index 00000000..4f225fed --- /dev/null +++ b/doc/pddp/help-tabread.pd @@ -0,0 +1,93 @@ +#N canvas 2 1 648 608 12; +#X obj 114 560 pddp; +#X obj 8 3 cnv 15 90 578 empty empty empty 20 12 0 14 -233017 -66577 +0; +#X text 14 223 ARGUMENTS:; +#X text 19 323 EXAMPLES:; +#X text 22 471 SEE ALSO:; +#N canvas 58 0 405 254 Related_Objects 0; +#X text 25 11 Native PD Objects; +#X text 16 166 Externals and other object libraries; +#X obj 16 41 tabread~; +#X obj 90 41 tabread4; +#X obj 165 41 tabwrite; +#X obj 240 41 tabwrite~; +#X obj 16 67 tabsend~; +#X obj 92 67 tabreceive~; +#X obj 192 67 tabplay~; +#X obj 269 67 table; +#X text 15 124 [array]; +#X obj 16 94 soundfiler; +#X text 78 124 and fft objects.; +#X text 21 187 [tabdump]; +#X obj 112 94 tabread4~; +#X text 20 207 [tabenv]; +#X obj 203 94 getsize; +#X obj 274 94 setsize; +#X text 238 207 [arraysize]; +#X text 238 186 [score]; +#X text 114 186 [linear_path]; +#X text 114 207 [plot]; +#X restore 114 508 pd Related_Objects; +#N canvas 80 0 655 534 More_Info 0; +#X text 25 16 WHAT IS THE DIFFERENCE BETWEEN A TABLE AND AN ARRAY AND +A GRAPH AND A TEMPLATE AND A LIST AND A SCALAR AND A WIDGET?; +#X text 43 56 That question isn't relevant yet \, but I know you're +probably asking it. Let's just set aside these terms and their uses +and say the following:; +#X text 67 114 1 In PD \, the terms "graph" and "table" are almost +synonymous.; +#X text 66 164 2 A table in PD is a convenient place to store an array. +; +#X text 65 392 5 For more discussion about arrays and tables \, please +see the help documentation in: doc/2.control.examples/15.arrays.pd +and doc/5.reference/table.pd; +#X text 44 487 Also See:; +#X obj 123 487 all_about_arrays; +#X text 66 195 3 When you create a table \, an array of 100 elements +is automatically created inside that table. The name of the table and +the name of the array are stored separately. This means \, that although +the table has the same name as the default array \, you can rename +one or the other individually.; +#X text 66 307 4 [tabread] is designed to read the numbers from arrays +- whether they're stored in tables or not! Perhaps we can think of +this object as [arrayread] instead? Keep in mind that arrays can be +created separately from tables.; +#X restore 114 534 pd More_Info; +#X obj 32 10 tabread; +#X text 111 10 - READ NUMBERS FROM A TABLE; +#X text 104 277 One - outputs a floating point number which corresponds +to the index you query using the inlet.; +#X obj 161 416 tabread davids_table; +#X floatatom 161 443 0 0 0 3 - - -; +#X floatatom 116 364 0 0 99 1 index - -; +#X msg 241 391 set another_table; +#X msg 203 366 set davids_table; +#X text 105 168 Set - the "set " message allows you to read +from dynamic sources. You can change the source at any time using the +"set" message.; +#X text 105 223 One - the argument informs [tabread] which array to +read. The array must exist in an open PD patch/canvas or an error message +will appear in the terminal window.; +#X text 29 278 OUTLETS:; +#X text 410 433 tables which store \; arrays of the same name.; +#X obj 413 384 table davids_table; +#X obj 413 410 table another_table; +#X text 113 443 value; +#X text 158 561 - Dave Sabine \, April 25 \, 2003; +#X text 106 323 Open the tables and use your mouse to draw new values +in the arrays - otherwise [tabread] will always output "0".; +#X text 39 34 INLETS:; +#X text 107 34 Float - A float at the left inlet will move to the corresponding +index in the table's array. The lowest valid number is "0" which represents +the first element of the array. The highest valid number is the size +of the array minus 1 By default \, the size of an array in a table +is 100 - or 0 to 99 The actual size of the array can be altered using +the array's dialog box or the resize command. More about arrays can +be found below.; +#X text 112 470 doc/2.control.examples/15.arrays.pd; +#X text 113 489 doc/2.control.examples/16.more.arrays.pd; +#X connect 10 0 11 0; +#X connect 12 0 10 0; +#X connect 13 0 10 0; +#X connect 14 0 10 0; diff --git a/doc/pddp/help-tabread4.pd b/doc/pddp/help-tabread4.pd new file mode 100644 index 00000000..b57ec857 --- /dev/null +++ b/doc/pddp/help-tabread4.pd @@ -0,0 +1,148 @@ +#N canvas 2 1 658 618 12; +#X obj 114 560 pddp; +#X obj 8 3 cnv 15 90 578 empty empty empty 20 12 0 14 -233017 -66577 +0; +#X text 14 213 ARGUMENTS:; +#X text 19 323 EXAMPLES:; +#X text 22 471 SEE ALSO:; +#N canvas 58 0 407 256 Related_Objects 0; +#X text 25 11 Native PD Objects; +#X text 16 166 Externals and other object libraries; +#X obj 16 41 tabread~; +#X obj 165 41 tabwrite; +#X obj 240 41 tabwrite~; +#X obj 16 67 tabsend~; +#X obj 92 67 tabreceive~; +#X obj 192 67 tabplay~; +#X obj 269 67 table; +#X text 15 124 [array]; +#X obj 16 94 soundfiler; +#X text 78 124 and fft objects.; +#X text 21 187 [tabdump]; +#X obj 112 94 tabread4~; +#X text 20 207 [tabenv]; +#X obj 203 94 getsize; +#X obj 274 94 setsize; +#X text 238 207 [arraysize]; +#X text 238 186 [score]; +#X text 114 186 [linear_path]; +#X text 114 207 [plot]; +#X obj 90 41 tabread; +#X restore 114 508 pd Related_Objects; +#N canvas 80 0 659 614 More_Info 0; +#X text 46 564 Also See:; +#X obj 125 564 all_about_arrays; +#X text 21 8 WHAT IS INTERPOLATION?; +#X text 38 34 "Interpolation" is a word which described a sophisticated +way to "connect-the-dots". (This is over simplified \, but effective +for the time being.); +#X text 17 85 Let's say for example that we have an array whose values +are: 0 \, 6 \, 5; +#X text 36 120 There are 3 elements in this array \, right? Well \, +using [tabread] we could successfully read only 3 numbers. But interpolation +allows us to fill in the gaps between those values in a meaningful +way. For example \, we can assume that between 0 and 6 \, we might +find 4.5! We can also assume that the slope from 0 to 6 will be sharper +than the slope from 6 to 5 In this way \, using [tabread4] will allow +us to create much smoother lines and curves between our "dots".; +#X text 35 254 However \, this process is much more complicated than +mere "smoothing". 4-point interpolation incorporates a sophisticated +formula to intelligently create meaningful increments between values +in an array. For example: we could draw a few points on a baseball +diamond between the pitcher's mound and home plate. Those points could +represent the path a ball travels after a pitch. Using 4-point interpolation +\, we might be able to assume the positions of the ball between our +"known" points and determine whether the pitch was a fastball or a +curve ball.; +#X text 35 419 There are different formulas used to interpolate arrays. +Each method has a sort of niche where it is most comfortable and most +effective. PD \, like most contemporary audio software \, uses 4-point +interpolation which is also known as "Hermite" interpolation. It is +the most "intelligent" 2-dimensional method of interpolation.; +#N canvas 167 0 570 613 What_does_it_really_do? 0; +#X text 20 10 Let's see [tabread4] at work...; +#N canvas 0 0 450 300 graph36 0; +#X array original_array 10 float 1; +#A 0 -0.324999 -0.274999 -0.0749997 0.174999 -0.624998 0.649998 0.599998 +0.524998 -0.749997 -0.774996; +#X coords 0 1 9 -1 200 140 1; +#X restore 292 9 graph; +#X text 37 158 The array above has only 10 elements. You can draw new +shapes with your mouse.; +#X obj 14 202 bng 15 250 50 0 empty empty Bang_me 18 7 0 8 -24198 -1 +-1; +#X obj 88 246 until; +#N canvas 0 0 450 300 graph37 0; +#X array interpolation 1000 float 0; +#X coords 0 1 999 -1 200 140 1; +#X restore 304 445 graph; +#X obj 84 341 tabread4 original_array; +#X obj 88 270 f; +#X obj 118 270 + 1; +#X obj 84 368 tabwrite interpolation; +#X obj 87 295 t f f; +#X obj 14 222 t b b; +#X msg 48 250 0; +#X obj 86 318 / 100; +#X msg 88 222 1000; +#X text 36 395 The array below has 1000 elements. At this resolution +\, you will see the overall effect of 4-point interpolation.; +#X connect 3 0 11 0; +#X connect 4 0 7 0; +#X connect 6 0 9 0; +#X connect 7 0 8 0; +#X connect 7 0 10 0; +#X connect 8 0 7 1; +#X connect 10 0 13 0; +#X connect 10 1 9 1; +#X connect 11 0 14 0; +#X connect 11 1 12 0; +#X connect 12 0 7 1; +#X connect 13 0 6 0; +#X connect 14 0 4 0; +#X restore 36 526 pd What_does_it_really_do?; +#X restore 114 534 pd More_Info; +#X floatatom 161 443 0 0 0 3 - - -; +#X floatatom 116 364 0 0 1000 1 location - -; +#X msg 286 389 set another_table; +#X text 106 162 Set - the "set " message allows you to read +from dynamic sources. You can change the source at any time using the +"set" message.; +#X text 29 266 OUTLETS:; +#X obj 486 442 table another_table; +#X text 106 323 Open the tables and use your mouse to draw new values +in the arrays - otherwise [tabread] will always output "0".; +#X text 39 34 INLETS:; +#X text 112 470 doc/2.control.examples/15.arrays.pd; +#X text 113 489 doc/2.control.examples/16.more.arrays.pd; +#X obj 21 10 tabread4; +#X text 111 10 - READ NUMBERS FROM A TABLE WITH 4-POINT INTERPOLATION +; +#X text 105 213 One - the argument informs [tabread4] which array to +read. The array must exist in an open PD patch/canvas or an error message +will appear in the terminal window.; +#X text 104 265 One - outputs a floating point number representing +an interpolation of the array value corresponding to the location described +at the inlet.; +#X text 107 34 Float - A float at the left inlet will move to the corresponding +location in the table's array. The lowest valid number is "0" which +represents the first element of the array. The highest valid number +is a fraction below the actual length of the array. Each fractional +increment between the lower and upper bounds of the array will produce +an interpolation of the actual array values at the outlet.; +#X msg 248 364 set davids_array; +#N canvas 0 0 450 300 graph27 0; +#X array davids_array 10 float 1; +#A 0 0 0.749989 0 -0.849987 0 -0.349995 0.949986 0 -0.699989 -0.399994 +; +#X coords 0 1 9 -1 100 40 1; +#X restore 526 380 graph; +#X text 249 444 interpolation; +#X obj 121 390 / 100; +#X obj 161 416 tabread4 davids_array; +#X text 158 561 - Dave Sabine \, May 2 \, 2003; +#X connect 8 0 25 0; +#X connect 9 0 26 0; +#X connect 22 0 26 0; +#X connect 25 0 26 0; +#X connect 26 0 7 0; diff --git a/doc/pddp/help-tabwrite.pd b/doc/pddp/help-tabwrite.pd new file mode 100644 index 00000000..ef8a75c5 --- /dev/null +++ b/doc/pddp/help-tabwrite.pd @@ -0,0 +1,98 @@ +#N canvas 2 1 650 610 12; +#X obj 114 560 pddp; +#X obj 8 3 cnv 15 90 578 empty empty empty 20 12 0 14 -233017 -66577 +0; +#X text 14 223 ARGUMENTS:; +#X text 20 303 EXAMPLES:; +#X text 22 471 SEE ALSO:; +#N canvas 58 0 407 256 Related_Objects 0; +#X text 25 11 Native PD Objects; +#X text 16 166 Externals and other object libraries; +#X obj 16 41 tabread~; +#X obj 90 41 tabread4; +#X obj 240 41 tabwrite~; +#X obj 16 67 tabsend~; +#X obj 92 67 tabreceive~; +#X obj 192 67 tabplay~; +#X obj 269 67 table; +#X text 15 124 [array]; +#X obj 16 94 soundfiler; +#X text 78 124 and fft objects.; +#X text 21 187 [tabdump]; +#X obj 112 94 tabread4~; +#X text 20 207 [tabenv]; +#X obj 203 94 getsize; +#X obj 274 94 setsize; +#X text 238 207 [arraysize]; +#X text 238 186 [score]; +#X text 114 186 [linear_path]; +#X text 114 207 [plot]; +#X obj 165 41 tabread; +#X restore 114 508 pd Related_Objects; +#N canvas 80 0 661 319 More_Info 0; +#X text 28 257 Also See:; +#X obj 107 257 all_about_arrays; +#X text 26 21 In this help document \, the [tabwrite] object is set +to write values to one of the two arrays you see on your screen. The +[tabwrite] will just as easily write values to tables buried in the +[table] object. This terminology is somewhat confusing \, but the objects +"array" and "table" exist separately because they offer different speeds +of performance.; +#X text 25 150 For example \, the; +#X obj 163 150 tabread; +#X text 229 150 documentation shows similar; +#X text 24 169 functionality using [table] instead of array. In this +particular document \, I chose to sacrifice speed for the sake of visually +displaying the effectiveness of [tabwrite].; +#X restore 114 534 pd More_Info; +#X obj 32 10 tabread; +#X floatatom 303 407 0 0 99 1 index - -; +#X text 29 278 OUTLETS:; +#X text 107 303 Open the tables and use your mouse to draw new values +in the arrays - otherwise [tabread] will always output "0".; +#X text 39 34 INLETS:; +#X text 112 470 doc/2.control.examples/15.arrays.pd; +#X text 113 489 doc/2.control.examples/16.more.arrays.pd; +#X text 111 10 - WRITE NUMBERS TO A TABLE; +#X text 38 50 - LEFT:; +#X text 107 51 Float - A float at the left inlet will become the new +value of the chosen index (whichever index is currently selected at +the right inlet).; +#X text 105 101 List - The left inlet also accepts pairs of floats +(longer lists will be truncated). A number pair represents "value" +and "index" - corresponding to "left" and "right" inlets.; +#X text 105 151 Set - the "set " message allows you to write +to dynamic locations. You can change the table at any time using the +"set" message.; +#X text 158 561 - Dave Sabine \, April 29 \, 2003; +#X text 29 203 - RIGHT:; +#X text 104 203 Float - selects which index in which to write the new +value.; +#X text 105 223 One - the argument informs [tabwrite] which array to +write to. The array must exist in an open PD patch/canvas or an error +message will appear in the terminal window.; +#X text 104 277 None.; +#X obj 161 437 tabwrite davids_array; +#X msg 220 375 set another_array; +#X msg 204 346 set davids_array; +#X floatatom 148 381 0 0 0 0 value - -; +#N canvas 0 0 450 300 graph12 0; +#X array davids_array 100 float 1; +#A 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2.75 0 0 0 0 0 +0 0 0; +#X coords 0 1 99 -1 100 70 1; +#X restore 528 343 graph; +#N canvas 0 0 450 300 graph12 0; +#X array another_array 100 float 1; +#A 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 -0.67 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0; +#X coords 0 1 99 -1 100 70 1; +#X restore 528 417 graph; +#X connect 8 0 24 1; +#X connect 25 0 24 0; +#X connect 26 0 24 0; +#X connect 27 0 24 0; diff --git a/doc/pddp/help-timer.pd b/doc/pddp/help-timer.pd new file mode 100644 index 00000000..f10b01b6 --- /dev/null +++ b/doc/pddp/help-timer.pd @@ -0,0 +1,108 @@ +#N canvas 11 8 937 643 10; +#X msg 43 113 bang; +#X msg 18 91 bang; +#X obj 18 135 timer; +#X obj 25 15 timer; +#X floatatom 18 157 0 0 0; +#X text 90 159 Output is in milliseconds; +#X text 65 16 -- measure logical time; +#X text 53 91 Click here to start or reset; +#X text 13 44 The [timer] object measures elapsed logical time. Logical +time moves forward as if all computation were instantaneous and as +if all [delay] and [metro] objects were exact.; +#X text 11 185 [timer] works like essentially like a stop-watch. Once +it starts \, you can continue to "poll" the [timer] to view the elapsed +time.; +#X text 81 114 Click here to get elapsed logical time. Click again...and +again...to see periodic measurements from the start or reset time. +; +#X text 10 282 As stated above \, [timer] measures "logical" time. +This value may be slightly different that CPU time or "real" time. +PD offers two objects which measure CPU time and "real" time. See the +reference documents for those objects for more information.; +#X obj 52 545 time_measurements; +#X obj 52 441 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 17 572 0 0 0; +#X floatatom 108 585 0 0 0; +#X floatatom 175 573 0 0 0; +#X text 11 358 In the example below \, I've created an abstraction +which will force each of PD's stop-watches \, [timer] [cputime] and +[realtime] to measure various processes and report the elapsed time. +Click on each [bng] to begin the process and wait for the results. +Notice the discrepancies in the results.; +#X text 15 587 Logical Time; +#X text 173 587 Real Time; +#X text 107 601 CPU Time; +#X obj 67 477 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 72 435 1 Measures elapsed time between two "bangs" from a [trigger] +object.; +#X text 87 469 2 Measures the amount of time PD requires to turn on +DSP and start an oscillator.; +#X obj 445 484 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 445 17 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 472 36 WHY THE DISCREPANCIES BETWEEN CLOCKS?; +#X text 475 59 In a fantasy world \, computers could exist somehow +beyond the restrictions of time and digital computation could be performed +in ZERO time. However \, that is not the case. Instead \, every process +within PD and within your operating system requires at least a few +nanoseconds of your CPU's time.; +#X obj 111 509 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 476 144 The [timer] object is like a clock that is not constrained +to the regular laws of physics and the universal space-time continuum. +It reports "time" measurements as only PD can see them!; +#X text 477 204 The [cputime] object is like a clock that measures +how much time your CPU actually required to carry out your request. +Keep in mind however that your CPU is busy doing many things simoultaneously +\, so even though a process might take 5 minutes to complete \, your +CPU does not pay full attention to that process for the entire 5 minutes. +Instead \, it simply begins the process \, then refers back to that +process from time to time until the it is complete. In other cases +\, your CPU might require a full 5 minutes while PD might report that +merely a few milliseconds have passed. This type of discrepancy depends +heavily on your computer's hardware and the type of processing it is +performing.; +#X text 478 368 The [realtime] object is as much like your own wrist +watch as PD can possibly manage. It measures time according to your +operating system's internal clock.; +#N canvas 0 0 454 304 related_objects_from_other_libraries 0; +#X text 27 63 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 26 112 The best places to find information about PD's libraries +is:; +#X text 23 134 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 25 149 or; +#X text 25 164 iem.kug.ac.at/pdb/; +#X obj 44 24 t3_timer; +#X text 469 589 This document was updated for PD version 0.35 test +26 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X restore 505 476 pd related_objects_from_other_libraries; +#X text 309 580 This document was updated for PD version 0.35 test +28 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X text 11 232 The odd aspect about comparing [timer] to a stop-watch +is that a stop-watch can be stopped! [timer] can only be started or +reset. It cannot be stopped.; +#X obj 625 445 metro; +#X text 504 422 RELATED OBJECTS; +#X obj 504 446 cputime; +#X obj 562 445 realtime; +#X text 132 501 3 Measures the amount of time PD requires count to +three...please wait for approximately 3 seconds.; +#X connect 0 0 2 1; +#X connect 1 0 2 0; +#X connect 2 0 4 0; +#X connect 12 0 14 0; +#X connect 12 1 15 0; +#X connect 12 2 16 0; +#X connect 13 0 12 0; +#X connect 21 0 12 1; +#X connect 25 0 24 0; +#X connect 28 0 12 2; diff --git a/doc/pddp/help-trigger.pd b/doc/pddp/help-trigger.pd new file mode 100644 index 00000000..a5a10051 --- /dev/null +++ b/doc/pddp/help-trigger.pd @@ -0,0 +1,225 @@ +#N canvas 20 8 893 651 10; +#X obj 26 16 trigger; +#X text 26 45 The trigger object outputs its input from right to left +\, converting to the types indicated by its creation arguments. There +is also a "pointer" argument type (see the pointer object.); +#X text 24 230 As I see it \, the [trigger] object serves two great +purposes which aren't really related - but they might be on some level +that I don't fully understand yet.; +#X text 97 15 - sequence messages in right-to-left order and convert +data types.; +#X text 22 278 1 Sequence a series of bangs - or triggers for symbols +and/or other messages. In the example below \, you should see that +it is important that it is important that [metro] gets a tempo setting +before it is started - but let's assume for a moment that you wanted +to start the [metro] with only a single click.; +#X obj 26 481 metro; +#X msg 51 462 1000; +#X obj 26 501 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 26 404 tgl 15 0 empty empty On/Off 0 -6 0 7 -262144 -1 -1 0 +1; +#X text 20 364 Click the toggle to set the tempo and start the metro +simoultaneously.; +#X text 24 109 The [trigger] object can be abbreviated as "t" and the +creation arguments can be abbreviated as follows:; +#X text 25 135 Floats = f; +#X text 25 147 Bangs = b; +#X text 24 159 Symbols = s; +#X text 25 173 Lists = l; +#X text 25 201 Anythings = a; +#X text 25 187 Pointers = p; +#X obj 103 150 trigger float bang symbol list pointer anything; +#X text 204 169 is the same as; +#X obj 207 189 t f b s l p a; +#X text 65 413 Triggers are sent from right to left...so our tempo +messages gets sent to [metro] immediately before the numbers from the +[toggle] to start and stop the [metro].; +#X obj 26 422 t f b; +#X text 27 526 This example is simple \, and may not be very practicle +in most situations \, but it clearly shows how [trigger] can be used +to create a simple sequence of events. It is important to note however +that the messages sent from [trigger]'s outlets occur in ZERO time +with no delay between the events...more at the top right of the page... +; +#X obj 430 94 t b b; +#X msg 430 75 bang; +#X obj 430 124 timer; +#X floatatom 430 144 5 0 0; +#X obj 399 34 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 399 600 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 428 40 Below is a simple structure which will measure the "logical +time" between bangs from the [trigger] object.; +#X text 464 75 Click here.; +#X text 470 141 Watch here.; +#X text 417 163 Now \, to prove that I'm not crazy...click here >; +#X msg 705 162 bang; +#X obj 705 203 timer; +#X floatatom 705 222 5 0 0; +#X obj 730 182 delay 2000; +#X text 543 89 any delay between the first bang and the second bang +; +#X text 544 105 from the trigger.; +#X text 415 179 In this case \, I've simply patched a delay; +#X text 414 193 object to force a 2 second delay between the; +#X text 414 207 first and second bangs sent to the [timer].; +#X text 545 75 In this case \, the [timer] object does not perceive +; +#X text 417 290 2 Click this subpatch to read about [trigger]'s second +great purpose...; +#N canvas 148 20 927 612 trigger_can_convert_data_types 0; +#X msg 425 103 2.5; +#X msg 523 103 bang; +#X msg 465 103 23 64; +#X msg 569 103 symbol dog; +#X obj 425 228 trigger float bang symbol list anything; +#X text 24 24 All sophisticated programming environments provide tools +to convert data types. For instance \, Visual Basic has:; +#X text 24 55 - VarType: to check the data type.; +#X text 24 70 - CStr: to convert a variable to a string.; +#X text 23 84 - CDate: to convert a variable to a date.; +#X text 24 99 - isNumeric: to test whether the variable is a number. +; +#X text 22 113 - etc.; +#X text 19 137 [trigger] is one object in PD which can convert an incoming +atom to a different type of atom.; +#X text 422 30 In the example below \, you can see that this [trigger] +has creation arguments which specify what data type the object should +output through each outlet. Messages which are sent to the first outlet +will be floats \; the second outlet will send bangs \; the third \, +symbols \; etc.; +#X text 19 172 To prove this \, click on each of the messages below +and watch your terminal window for the output.; +#X obj 20 239 t b; +#X msg 20 210 bang; +#X msg 57 210 1; +#X floatatom 90 212 5 0 0; +#X msg 132 211 symbol cat; +#X msg 204 211 this is anything; +#X obj 20 259 print all_messages_are_converted_to_bangs; +#X text 20 292 Another example showing floats and symbols.; +#X msg 20 308 bang; +#X floatatom 90 310 5 0 0; +#X msg 132 309 symbol cat; +#X msg 206 319 this is anything; +#X obj 20 337 t f s; +#X msg 57 308 1 0; +#X obj 45 387 print converted_to_symbols; +#X obj 20 407 print converted_to_floats; +#X text 62 338 Note that "this is anything" causes an error. That is +because 'anythings' don't conform to floats \, symbols \, lists \, +pointers. They can only be converted to "bang".; +#X text 18 430 In the example above \, note that the trigger object +does not split a list among the outlets like [unpack] does. Instead +it sends all list elements through all outlets and converts them as +necessary.; +#X text 20 486 Also note that some messages don't convert as nicely +as others. Hence \, the symbol "cat" converts to a ZERO when [trigger] +converts that symbol into a float. Likewise \, all numbers will convert +to a symbol called "float" when sent through [trigger]'s right-most +outlet.; +#X floatatom 425 248 5 0 0; +#X obj 482 248 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X symbolatom 539 286 10 0 0; +#X floatatom 594 162 5 0 0; +#X obj 594 200 pack f s; +#X msg 637 161 symbol earth; +#X msg 652 181 symbol jupiter; +#X obj 596 267 print a_list; +#X floatatom 426 403 5 0 0; +#X symbolatom 470 403 10 0 0; +#X obj 514 421 print another_list; +#X text 630 131 Click on all these.; +#X obj 426 363 r anythings; +#X text 425 303 Note how each of the messages sent to this trigger +are converted appropriately for their receiving atoms boxes. Also note +that "anythings" are sent to the example below.; +#X text 430 447 I'e used the [route] object to show how "anythings" +are converted as they pass through the above [trigger]. Note that all +messages converted to floats are displayed here in the number box \, +all symbols are displayed in the symbol box \, and all lists are printed +to the terminal window.; +#X obj 654 247 s anythings; +#X obj 426 383 route float symbol list; +#X msg 642 103 symbol cat; +#X connect 0 0 4 0; +#X connect 1 0 4 0; +#X connect 2 0 4 0; +#X connect 3 0 4 0; +#X connect 4 0 33 0; +#X connect 4 1 34 0; +#X connect 4 2 35 0; +#X connect 4 3 40 0; +#X connect 4 4 48 0; +#X connect 14 0 20 0; +#X connect 15 0 14 0; +#X connect 16 0 14 0; +#X connect 17 0 14 0; +#X connect 18 0 14 0; +#X connect 19 0 14 0; +#X connect 22 0 26 0; +#X connect 23 0 26 0; +#X connect 24 0 26 0; +#X connect 25 0 26 0; +#X connect 26 0 29 0; +#X connect 26 1 28 0; +#X connect 27 0 26 0; +#X connect 36 0 37 0; +#X connect 37 0 4 0; +#X connect 38 0 37 1; +#X connect 39 0 37 1; +#X connect 45 0 49 0; +#X connect 49 0 41 0; +#X connect 49 1 42 0; +#X connect 49 2 43 0; +#X connect 50 0 4 0; +#X restore 421 325 pd trigger_can_convert_data_types; +#X obj 705 238 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 785 164 5 0 0; +#X text 415 227 You can reset the delay with the number box; +#X text 415 241 at the top-right to clearly see "logical time"; +#X text 415 254 as measured by [timer].; +#X text 459 579 This document was updated for PD version 0.35 test +26 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X text 418 378 RELATED OBJECTS; +#X obj 503 404 route; +#X obj 423 404 unpack; +#X obj 469 404 pack; +#X obj 544 404 delay; +#X obj 586 404 pipe; +#X obj 621 404 float; +#X obj 661 404 int; +#X obj 690 404 symbol; +#N canvas 0 0 456 306 related_objects_from_other_libraries 0; +#X obj 31 36 exciter; +#X text 26 77 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 25 126 The best places to find information about PD's libraries +is:; +#X text 22 148 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 24 163 or; +#X text 24 178 iem.kug.ac.at/pdb/; +#X restore 423 435 pd related_objects_from_other_libraries; +#X connect 5 0 7 0; +#X connect 6 0 5 1; +#X connect 8 0 21 0; +#X connect 21 0 5 0; +#X connect 21 1 6 0; +#X connect 23 0 25 1; +#X connect 23 1 25 0; +#X connect 24 0 23 0; +#X connect 25 0 26 0; +#X connect 27 0 28 0; +#X connect 33 0 34 0; +#X connect 33 0 36 0; +#X connect 34 0 35 0; +#X connect 35 0 45 0; +#X connect 36 0 34 1; +#X connect 46 0 36 1; diff --git a/doc/pddp/help-unpack.pd b/doc/pddp/help-unpack.pd new file mode 100644 index 00000000..29a3c299 --- /dev/null +++ b/doc/pddp/help-unpack.pd @@ -0,0 +1,49 @@ +#N canvas 18 16 471 443 10; +#X floatatom 61 204 0 0 0; +#X floatatom 186 204 0 0 0; +#X floatatom 224 204 0 0 0; +#X floatatom 27 204 0 0 0; +#X obj 24 294 pack; +#X obj 41 11 unpack; +#X msg 27 126 1 2; +#X msg 65 126 3 4 shut; +#X msg 145 126 5 6 pick 7 8; +#X text 90 11 - split a message into atoms; +#X text 20 41 [unpack] takes lists of atoms and distributes them to +its outlets. The creation arguments are used to specify the types of +atoms expected in the incoming list and specify float (any number or +the symbol 'f') \, pointer (symbol 'p') or symbol (symbol 's').; +#X symbolatom 103 207 10 0 0; +#X obj 27 163 unpack 0 0 s f f; +#X text 23 268 RELATED OBJECTS; +#X obj 61 294 trigger; +#N canvas 0 0 452 302 related_objects_from_other_libraries 0; +#X obj 21 16 pack~; +#X obj 61 16 unpack~; +#X obj 113 16 tabdump; +#X obj 169 16 niagara; +#X obj 224 16 packel; +#X obj 21 42 repack; +#X obj 70 42 drip; +#X obj 107 42 sort; +#X text 18 86 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 17 135 The best places to find information about PD's libraries +is:; +#X text 14 157 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 15 173 or; +#X text 16 187 iem.kug.ac.at/pdb/; +#X restore 24 333 pd related_objects_from_other_libraries; +#X text 27 363 This document was updated for PD version 0.35 test 26 +by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X connect 6 0 12 0; +#X connect 7 0 12 0; +#X connect 8 0 12 0; +#X connect 12 0 3 0; +#X connect 12 1 0 0; +#X connect 12 2 11 0; +#X connect 12 3 1 0; +#X connect 12 4 2 0; diff --git a/doc/pddp/help-until.pd b/doc/pddp/help-until.pd new file mode 100644 index 00000000..afb562cd --- /dev/null +++ b/doc/pddp/help-until.pd @@ -0,0 +1,89 @@ +#N canvas 59 5 829 645 10; +#X msg 28 525 bang; +#X obj 25 13 until; +#X obj 28 546 until; +#X text 59 525 start; +#X obj 28 568 f; +#X obj 57 568 + 1; +#X obj 103 570 sel 0; +#X obj 28 612 print; +#X obj 57 590 mod 10; +#X text 19 42 Every modern programming language will have various "looping" +mechanisms: either in the form of an object \, or as a data structure. +For example in Visual Basic:; +#X text 30 100 DO UNTIL i = 100; +#X text 30 114 i = i + 1; +#X text 31 85 i = 0; +#X text 30 129 LOOP; +#X text 15 210 And now PD's version of the above programming structures: +; +#X obj 24 257 until; +#X msg 24 237 100; +#X obj 24 277 print i; +#X text 17 304 If you start [until] with a "bang" \, it will begin +an infinite loop! Please plan ahead in this case so that there is a +mechanism in place to stop the loop - otherwise PD will effectively +freeze.; +#X text 17 361 HOW TO FREEZE PD; +#X msg 25 384 bang; +#X obj 25 404 until; +#X obj 25 424 print; +#X text 63 384 DO NOT CLICK. DO NOT CLICK. DO NOT CLICK.; +#X text 66 404 If you click \, click the "close window" (X) button +on PD's terminal window - or reboot the computer.; +#X text 17 145 OR:; +#X text 29 161 FOR i = 0 TO 100; +#X text 28 187 NEXT; +#X text 29 175 ' do something; +#X text 26 493 The example below includes a method to stop the loop +to prevent PD from looping infinitely.; +#X text 434 44 If you start [until] with a number \, it iterates that +number of times. The [uzi] object in MAX works the same way.; +#X obj 441 131 until; +#X msg 441 84 100; +#X obj 441 151 print i; +#X msg 469 91 3; +#X msg 497 98 42; +#X text 26 451 The [until] object's left inlet starts a loop in which +it outputs "bang" until its right inlet gets a "bang" which stops it. +; +#X obj 413 17 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 413 605 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 67 13 - LOOPing mechanism; +#X text 442 580 This document was updated for PD version 0.35 test +26 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X text 436 185 RELATED OBJECTS; +#X text 441 204 ?? This author does not know of any other native looping +mechanisms in PD.; +#N canvas 0 0 452 302 related_objects_from_other_libraries 0; +#X text 27 63 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 26 112 The best places to find information about PD's libraries +is:; +#X text 23 134 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 25 149 or; +#X text 25 164 iem.kug.ac.at/pdb/; +#X obj 43 32 for++; +#X restore 449 244 pd related_objects_from_other_libraries; +#X connect 0 0 2 0; +#X connect 2 0 4 0; +#X connect 4 0 5 0; +#X connect 4 0 7 0; +#X connect 5 0 8 0; +#X connect 6 0 2 1; +#X connect 8 0 4 1; +#X connect 8 0 6 0; +#X connect 15 0 17 0; +#X connect 16 0 15 0; +#X connect 20 0 21 0; +#X connect 21 0 22 0; +#X connect 31 0 33 0; +#X connect 32 0 31 0; +#X connect 34 0 31 0; +#X connect 35 0 31 0; +#X connect 37 0 38 0; diff --git a/doc/pddp/help-value.pd b/doc/pddp/help-value.pd new file mode 100644 index 00000000..22ad7a3f --- /dev/null +++ b/doc/pddp/help-value.pd @@ -0,0 +1,102 @@ +#N canvas 1 1 889 657 10; +#X text 62 10 -- nonlocal shared value (named variable); +#X obj 21 10 value; +#X text 17 46 [value] is a container. It holds a global variable numeric +value and can be "polled" at any time with a "bang" message. In other +words \, [value] is a place where numbers can be stored and then accessed +by all active PD windows.; +#X text 16 109 SCOPE; +#X text 18 127 Understanding "scope" is important while developing +programmatic applications. In PD there are three levels of "scope": +; +#X text 29 170 1 Local Scope: all objects \, subroutines \, data \, +and variables which exist within a single patch on a single computer +and do not communicate with other active PD patches.; +#X text 27 226 2 Global Scope: all objects \, subroutines \, data and +variables which exist within single or multiple patches on a single +computer which communicate with other active PD patches.; +#X text 17 354 As a general rule \, all things are considered "local" +in PD and if communication between PD windows is necessary \, then +[send]/[receive] \, or [throw]/[catch] objects are used. Likewise \, +if communication is necessary between many computers running PD \, +then objects such as [netsend]/[netreceive] are used.; +#X text 16 441 The exception to the above rule is [value]. This object +is a container which makes its data known to all [value] objects of +the same name in all active PD windows on a single computer: hence +\, GLOBAL scope.; +#X text 28 288 3 Network (Universal) Scope: all objects \, subroutines +\, data and variables which exist within single or multiple patches +on two or more computers which communicate with other active PD patches +via a network.; +#X text 419 15 To create a [value] object \, a name should be defined +for the variable that it will contain. For example:; +#X obj 422 54 value my_variable; +#X text 419 110 To assign a numeric value to that variable \, a number +box or message can be used \, as follows:; +#X obj 420 190 value my_variable; +#X msg 438 167 42; +#X text 12 523 The [value] object can be abbreviated as follows:; +#X obj 19 550 v; +#X text 48 550 is the same as; +#X obj 142 552 value; +#X obj 384 12 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 384 583 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 417 77 If no name is given \, then the object will communicate +with all other [value] objects with no name.; +#X floatatom 420 214 5 0 0; +#X floatatom 420 147 5 0 0; +#X obj 417 304 value my_variable; +#X floatatom 417 328 5 0 0; +#X obj 417 284 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 464 146 play with me; +#X text 463 166 or click me; +#X text 416 237 Notice that the number is not outputted to the outlet +\; it is merely stored. To retreive the number \, send a "bang" \, +like below:; +#X text 414 354 Now \, to show how global scope works \, click the +sub-patch below and then "bang" the [value] object to retreive the +current number. While you're in the sub-patch \, change the number +and then return to this window and click the above "bang". You'll quickly +see how this variable can be retreived or reset in any active PD window. +; +#N canvas 0 0 452 302 global_values 0; +#X obj 43 127 v my_variable; +#X floatatom 43 149 5 0 0; +#X obj 43 86 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 61 104 5 0 0; +#X connect 0 0 1 0; +#X connect 2 0 0 0; +#X connect 3 0 0 0; +#X restore 415 442 pd global_values; +#X text 414 474; +#X text 409 490 RELATED OBJECTS; +#N canvas 73 229 452 302 related_objects_from_other_libraries 0; +#X obj 28 37 getenv; +#X text 18 86 These objects are offered in PD only if you have downloaded +and properly installed the appropriate library. These objects may or +may not exist in a single library.; +#X text 17 135 The best places to find information about PD's libraries +is:; +#X text 14 157 www.pure-data.org and click on "Downloads" then "Software" +; +#X text 15 173 or; +#X text 16 187 iem.kug.ac.at/pdb/; +#X restore 413 551 pd related_objects_from_other_libraries; +#X obj 408 517 send; +#X obj 441 517 receive; +#X text 492 504 These objects are actually quite different than [value] +but it's important to understand that difference in relation to [value]. +; +#X text 252 603 This document was updated for PD version 0.35 test +26 by Dave Sabine as part of a project called pddp proposed by Krzysztof +Czaja to build comprehensive documentation for PD.; +#X connect 13 0 22 0; +#X connect 14 0 13 0; +#X connect 19 0 20 0; +#X connect 23 0 13 0; +#X connect 24 0 25 0; +#X connect 26 0 24 0; diff --git a/doc/pddp/midi-basics.pd b/doc/pddp/midi-basics.pd new file mode 100644 index 00000000..0950d9a7 --- /dev/null +++ b/doc/pddp/midi-basics.pd @@ -0,0 +1,45 @@ +#N canvas 224 22 443 646 10; +#X text 59 6 MIDI basics.; +#X text 11 54 MIDI in PD is handled through the 'raw' midi devices +(such as /dev/midi*). One could specify which MIDI port PD is supposed +to use through a command line switch when starting PD \, i.e.:; +#X text 35 126 pd -midiindev 1 -midioutdev 2; +#X text 43 287 pd -mididev 1; +#X text 17 315 This will use the first port for both MIDI input and +output.; +#X text 17 397 There is also a little bit of confusion about OSS midi +(which uses the raw midi - /dev/midi* - devices by default) and ALSA +(which is becoming very popular). ALSA uses /dev/snd/midiC*D* as their +raw midi devices. The C* (* = some number) is the device number while +D* (* = some number) is the port number. Normally the ALSA driver links +its raw devices to the corresponding /dev/midi* automatically (i.e.: +/dev/snd/midiC0d0 -> /dev/midi00 \, /dev/snd/midiC0D1 -> /dev/midi01 +etc).; +#X text 13 150 so \, the above will use the first MIDI device for MIDI +input (it could be a MIDI controller such as a keyboard \, midi-guitar +\, midi knob box etc) and the device #2 will be used for outputting +the MIDI (re)generated or sent by PD.; +#X text 13 232 For using the same device for MIDI input AND output +(i.e. when one uses a MIDI keyboard which is also a synthesizer) the +following command line switch will do:; +#X text 19 521 MIDI objects in PD (the ones that read and write to +MIDI ports) take a MIDI channel as an argument. Channels 1-16 use the +first MIDI device \, 17-32 use the second MIDI device and so on. For +this to work one must specify which devices PD is supposed to use: +; +#X text 39 599 -midiindev 1 \, 2 -- use devices 1 and 2 for input; +#X text 39 615 -midioutdev 1 \, 2 -- use devices 1 and 2 for output +; +#X text 39 631 -mididev 1 \, 2 -- use devices 1 and 2 for input and +output; +#X text 17 343 NOTE (Linux): PD counts the MIDI devices starting from +1 Usually \, the operating system counts them starting with 0 (zero) +so if you want to use /dev/midi00 \, PD has to be started with -mididev +1 Always add 1 to the device number.; +#X text 21 651 NOTE (Windows): -listdev command line option lists all +available MIDI and audio devices.; +#X text 19 678 A couple more useful command line options (related to +MIDI):; +#X text 21 694 -nomidiin -- do not listen to any midi input; +#X text 21 706 -nomidiout -- do not send any midi output; +#X text 21 718 -nomidi -- do not use any MIDI; diff --git a/doc/pddp/pddp.pd b/doc/pddp/pddp.pd new file mode 100644 index 00000000..787921e6 --- /dev/null +++ b/doc/pddp/pddp.pd @@ -0,0 +1,31 @@ +#N canvas 262 2 490 557 10; +#X text 14 17 PDDP: Pure Data Documentation Project; +#X text 25 40 The PDDP was proposed initially in early 2002 by Krzysztof +Czaja who suggested that Pure Data was in need of comprehensive documentation. +; +#X text 45 162 - Michal Seta; +#X text 45 135 - Miller Puckette; +#X text 45 148 - Dave Sabine; +#X text 25 89 The project is now managed un-officially by Dave Sabine +who acts as primary author and editor. The people involved in this +project include (alphabetically):; +#X text 25 184 PDDP will eventually be available in the main PD distribution +\, but for now is available at Dave's web site: http://www.davesabine.com/media/puredata.asp +; +#X text 25 231 All comments \, corrections \, etc. regarding the PDDP +reference files should be directed to Dave Sabine: dave@davesabine.com +; +#X text 14 282 THINGS TO NOTE:; +#X text 25 308 Authors: If you would like to participate in this project +\, simply gather together information about objects \, tutorials \, +examples \, etc. and contact Dave Sabine for info about formatting +your documents. All documents should then be forwarded to Dave to be +included in the PDDP download which is available at his web site.; +#X text 25 396 Externals and other Libraries: Each PDDP document includes +mention of "related objects from other PD libraries" as well as mention +of "related native PD objects". The objects from other libraries are +available only if you download those libraries from their respective +authors and integrate them properly into your version of PD. We do +not and cannot maintain a complete list of externals - but we try. +For more info about externals and other objects \, see http://www.pure-data.org/ +and the Pure Data Base at http://iem.kug.ac.at/pdb/; diff --git a/doc/pddp/time_measurements.pd b/doc/pddp/time_measurements.pd new file mode 100644 index 00000000..19f1dbb2 --- /dev/null +++ b/doc/pddp/time_measurements.pd @@ -0,0 +1,65 @@ +#N canvas 289 74 815 597 12; +#X obj 114 34 inlet; +#X obj 424 31 inlet; +#X obj 654 100 inlet; +#X obj 319 494 outlet; +#X obj 392 493 outlet; +#X obj 480 493 outlet; +#X obj 114 64 t b b; +#X obj 37 134 timer; +#X obj 104 135 cputime; +#X obj 183 136 realtime; +#X obj 299 62 osc~ 800; +#X msg 424 87 1; +#X msg 424 114 \; pd dsp \$1 \;; +#X msg 369 94 0; +#X obj 424 57 t b b; +#X obj 312 251 timer; +#X obj 379 252 cputime; +#X obj 455 251 realtime; +#X obj 298 86 env~; +#X obj 298 110 > 0; +#X obj 298 135 sel 1; +#X obj 569 162 delay 3000; +#X obj 654 132 t b b; +#X obj 585 242 timer; +#X obj 652 243 cputime; +#X obj 728 242 realtime; +#X connect 0 0 6 0; +#X connect 1 0 14 0; +#X connect 2 0 22 0; +#X connect 6 0 7 1; +#X connect 6 0 8 1; +#X connect 6 0 9 1; +#X connect 6 1 7 0; +#X connect 6 1 8 0; +#X connect 6 1 9 0; +#X connect 7 0 3 0; +#X connect 8 0 4 0; +#X connect 9 0 5 0; +#X connect 10 0 18 0; +#X connect 11 0 12 0; +#X connect 13 0 12 0; +#X connect 14 0 11 0; +#X connect 14 1 17 0; +#X connect 14 1 16 0; +#X connect 14 1 15 0; +#X connect 15 0 3 0; +#X connect 16 0 4 0; +#X connect 17 0 5 0; +#X connect 18 0 19 0; +#X connect 19 0 20 0; +#X connect 20 0 15 1; +#X connect 20 0 16 1; +#X connect 20 0 17 1; +#X connect 20 0 13 0; +#X connect 21 0 23 1; +#X connect 21 0 24 1; +#X connect 21 0 25 1; +#X connect 22 0 21 0; +#X connect 22 1 25 0; +#X connect 22 1 24 0; +#X connect 22 1 23 0; +#X connect 23 0 3 0; +#X connect 24 0 4 0; +#X connect 25 0 5 0; -- cgit v1.2.1