i built a little abstraction to visualize 2d input data with a data structures approach. it works quite well - but i was wondering if i might possibly skip the whole part of reading out the arrays and writing the x/y positions for every plot point there (with those [until] loops on [bang~]).

maybe the data-template itself could reference two arrays somehow which directly receive their data through [tabsend~]?

attaching the patch and a screenshot: scope2d~.pd

EDIT: this question was inspired by the interesting read of https://forum.pdpatchrepo.info/topic/12059/array-text-pointer

let's add this to the data structures manual!

feel free! i'd omit the dynamic blocksize in that case to make it even simpler and set the sample count to constant 1024 ... and i also just saw that the tabsend~ should directly write both arrays - no need to have 2 separate ones and a snake~ out:

• scope2d~-simple.pd

... but i'm still curious if there's an option to directly use the data written by tabsend~ ... i assume that it's not possible though since plot expects a 2d array and there's no way to directly tabsend~ to a 2d array?

this is almost what i had in mind with the original question and i'm actually a bit perplexed that it works: using array set with -s and -f flags now. that way, i can directly copy the whole array data to the fields of the plot data. didn't check what Pd is doing there technically, but damn, it's extremely cool! - and it also looks really simple now.

here's the patch and a screenshot: scope2d~-simple.pd

Anyway, this is a very nice 2D oscilloscope for Vanilla, congrats I wanna add this to the tutorials!

yeah, I'd tell you to use [array]

now that i know this is possible, it seems obvious to me, too! ... since the plotted array contains 2 fields though, i didn't assume that it would be an option to copy whole arrays for one field (but maybe the fields are internally represented as separate arrays anyway?).

and I don't think you can use other objects to write data to an array defined as a Data Structure scalar.

you're certainly right. although, technically, it could be an additional feature to also provide these -s and -f flags for tabsend~, which would spare the steps of copying the buffers twice.

you're certainly right. although, technically, it could be an additional feature to also provide these -s and -f flags for tabsend~, which would spare the steps of copying the buffers twice.

and [tabwrite~], the question is where to stop....

or maybe add a 'tabsend~' feature to [array] where it can be fed signals.

propose the feature

and [tabwrite~], the question is where to stop.... or maybe add a 'tabsend~' feature to [array] where it can be fed signals.

including these modes with [array] certainly sounds like a nice approach, too!

for now, i decided not to propose the feature on github yet though ... i assume that the additional array copy is negligible compared to the data structure drawing. it would certainly be nice to have - but i don't see a use case where this really becomes a requirement, i admit.

anyway, bring it up to github as a request and let the wizards tell you how negligible it is to the point we can forget about it then and make peace with this...

but maybe we could save CPU in more crazy situations, like plotting a 512 channel signal somehow