Roadmap to HISE 5

Allen

@Christoph-Hart
Thank you! That's awesome!
I'm ready to deep dive into the new wavetable engine!

d.healey

@Christoph-Hart Can we do this kind of thing now where each band gets a separate colour?

Also I made a few PR related to the filter panel, not sure how relevant they still are, but hopefully they can be incorporated.

https://github.com/christophhart/HISE/pull/681
https://github.com/christophhart/HISE/pull/705
https://github.com/christophhart/HISE/pull/704

dannytaurus

Is all this new stuff in the develop branch?

I'm getting close to finishing my first plugin. I don't need any of these new features.

Should I update to the latest develop? Or stick with the current version that's working for me?

Currently on a20873ea7a8c00b251ddae7df8d6e3007f8c5f71 "fix typo" from May 30th.

d.healey

@dannytaurus said in Roadmap to HISE 5:

Is all this new stuff in the develop branch?

That's where the good stuff always is :)

@dannytaurus said in Roadmap to HISE 5:

Should I update to the latest develop?

Yes, if it doesn't work for you, you can always go back.

dannytaurus

@d-healey said in Roadmap to HISE 5:

Yes, if it doesn't work for you, you can always go back.

Advance! Stop at nothing to advance! ️ ️ ️

Orvillain

HiseSnippet 1259.3oc6X0sSabDEdVfkFHMnRBpppRUZunWPphprAiCndAFL+TqD.KVGZTuIcX2yZOx6Ny1YmkhSTuqOO8UH8QnuB8Mf2f1yrqs20fCwrpIzTEeAh4Lmyb9N+eraJENPTjPRLluUuPfX7ol183pN06PYbRicHFKXd.MRARqTRa2KjFEAtDCio2WSvXtYHIetXyso9TtCjQhPNQvbfmxBXpLpMq8Dlu+dTWnEKHG2Up0vQvqK7EwHdl1rDIj5zk1FNjpYaJSx2Si5PL9Fy0VYUmJtO1ckUVaipNzpvFdTOuxq5VoR002n7paPqrdUnzZDiY20koDRaEUAQ3itsvsmcGwuvSUvIrH1o9f9PYhMp4Txj5cX9tMG3bhH3C0LyUMcpqZIyCXtrgzybYeVxEVYRj2oYL00Aox2.HYjCRyjBoEMscjrPU1MZ7bWyFbLB5QwXSdnjxKw3OLqKPF3puMf1E1ShGFJvxUKU5QV3ed324EycTLA2RvOTnfi3K+v4e07yM+uNu0kuxyar2oUiT36CxwdsNcPdcBtLON3TP9Hqyn9wvPFQyeTe5rSlO0I0pywnf2fyTGEB8Oumv2U6qz++Ui.j9tMcrnOBQVUIQhE5GIr8YtfjvvG4SLeBWbZYRB3yWjPdVicnJ5fmAeQTKgfTwzFiwNvYXQTZ.dNycfntJQXBuAgBtV+F26spzyyTX2Z8Fd3mZWKR0S6ZlMgQR.y00GZJhXZWetp6WiMABsYuLA4uZoee++5k+1lA4a.PHAzyy2OHJ1yicdRkqGyOHRgXqQ.VPSLtu4yh.KWviF6qrh5huiOi2EbaIR3OfhLedKprMnZflgo4AsdN153JY7XslvM1mpFs.T2Zp+EZyHeVuN0lilWu7P8FTUV5ZqJmTHtnYSlxoy3w3TiAiX1w6BL1uW18L20yCbTY.bFy8ddQabM4pegT0eWSaFGRl7jn7OO4r0OPOCr1G3fT67JeMCe9yIc3S3DO74HGEp9VRJOJTDMxCaCArVXoWTdhXB8dR3mOVGMySutfJG6UWr4dnQNVYropXYRZwVAhXtZjzfoGMNLyj0razJhb7OlIKybKLr6emxpawJ+QlGO2.LZyBB8gc4mA9XK8DLderGdReuATGMw9.AWD1QvYN4i5GCXCw1sAYdrOVCZKkBWaJixR0NF7AZ9L3ut1SwLOpD8SPA8E27cSFa75KLSgqktZz5C2N1S+tsiswTMuxl5KhKlqGRNDpIn7A8oZMjbgyt1lEJ7ox237n5wQJQP1z4St7dM1ABgpCi2dzVsMpc4VXENOKUmGS43NEDMLCiUomLLu9cSZf0dRUpOI+lMCXuEbtBWFKgIodfzgBY.0G4xsIHcvstz6wPNJV8lT4Eu9FpRb.B1JcvpWaE8ifTn4kT7X+JeL1++mX+swpZGKhUXPLMuBsxCiCrwMjb.T6bN3iOtowT5DhzykzmSWQh6lb3uwO8urr9rQ+KKO3x7l3cRMwuzbeewoT+rtv3WKBsVHMO+q5ecVdt0PFdOuj3k+lmEeh4Gt6b8fqDNh9336+S8EtdeTEm93o+NFuWTX.0QJdgS5u6htB5NITPm.O42KbNbZHd1ZL+fKAX0yKbbF8othfqTTAWsnBVonBtVQErZQE7wEUv0e6BpatsULteQZcJgbPycSRrLL1kSwT9jxCx+.b.nJz.

Quick snippet for multiple matrix modulators linked to a single knob. It works on MacOS. The UI knob controls the two matrix modulators, both given the id 'MTX'.

I tried this on Windows earlier, and it didn't work. Possibly I screwed something up. If anyone here is on Windows and could try this with the latest development and let me know, I'd be grateful. Otherwise I'll check it tomorrow!

Christoph Hart

@Orvillain haha, I think you became victim of the worst UX in HISE, but since I crammed that feature in last minute I haven't spent too many brain cells on how to present that feature :)

You must not set the ID of the matrix modulator to the same string (the ID must always be unique), instead, you need to enter the ID you want to use for both matrixes in the hidden and unlabeled text editor that shows up when you click on "Edit range properties" next to the button. This will be set to the ID as a default value but if you change it there, it will override the matrix target ID that is otherwise taken from the module ID as default behaviour.

Christoph Hart

Is there anything I should know about creating c++ nodes with sample accurate modulation, or is it the same as before?
(using parameters + hardcoded network)

Yes this has changed and you can use the new API to directly pick up the sample accurate control signal from any custom modulation slot and apply it to anywhere within your C++ code.

I'll write a simple example for that but I have to think about a good place to upload that as C++ stuff doesn't work well within the snippet system.

Also, out of curiosity, is the new WT synth oversampled, and what kind of interpolation does it use at runtime? Looks fun! I see you took the FFT approach for the band limiting.

HQ Mode => Cubic, otherwise linear interpolation. no oversampling is applied but since I'm fully band limiting the wavetables when creating the mip maps there is not much aliasing to occur.

Lindon

@Christoph-Hart said in Roadmap to HISE 5:

Alright, guys, big documentation update just dropped that explains most of the things I've been working on the last month(s).

modulation system - matrix modulators & scriptnode bridge

wavetable synth - file drop & script controller including post FX processors

draggable filter panel - connect to any filter module

Have fun and let me know if you find anything weird.

So a quick question here, having read the documentation on the new modulators system. Does this solve the "modulators hear every note and not all sound sources are responding" problem?

I know that's a mouthful, so here's an example snippet:

HiseSnippet 1844.3oc6astSabDEdWLSJFxEfPah5EosRUUPajEqgPfFEEyESfFbvB6PhT+QzvtisGw5Y1t6rzfpxyPek5iPeAZUdDxaP6Y1K16hMl0FHgzX+CKlyLyY9lybly47MxT1gaPbc4NJpiW8Xahh50QUNlIZrdCLkor8FJp2DUB6JHNZAhV6XarqKwTQUMySjBTyNph+m2830vVXlAosHEk84TCxNzlTQaokK7Tpk0lXSRUZyXidwBaavYqys3d.dxflWwFabHtN4YX4vFAorE1sgh5OfxW6.i70dvBKquh9JOXwUz0u+xGr374MLu+JKrvRKXVK+x3kVFlz0JZREbmJBrf3pnN5Zbyiqzf+arfEXepK8.KhrgtREXkCDuI2xTtEk+sx5MnVlkiLTtJJpeV41lsLAlsYPknlzVxaa9lzuCs1yHtATcjdAO83va9zCuQhAuQCf2TnJFNTaQ6djXaBz1L3jsFFNyhCqfwpn9mn04v.XhbMwGR1zAZzZBytz7yeOM3q4dXMOlgfxYZb1y3BxtrYma7ee7ri+lw0NYW0p009jKiC2xh3z0tktIN8Zhyx7Zd.w4dZGgs7HsFHr8SZeu1oaeie7aDrqiMPNaaFUrqMIrc6S.8tbBnDZ1f+54auAVfgCE0PYv3rINBpDNpaPNBtdDbDkEsAw8PA2Ftfzg60MPq5XSpWmhEgmc2LtD8jdUYRtqyjtccu1Gp2NzRCCU3inaF5QslmPvYJTSon.TDJx+rHdr.kTniaf1i3RDIUARsmSuhE0j33O8agdlWyJBhcnrVJXzTpfIPxY6ig9XCDSAS5qfJGR6.BpozD.Zf6HdJ4392PlbiXSHlOkwO3jJ36KzgBlLTAqyad.eM9q8UwznJje0i.QzaINcalXv3FncMD3iH6gY0I8+4YVTkFd0pYQFLuoIPEYXvUuJkbZPezfIOch0tLj2wWAy.lflzpbFIVGszz+BeLkWuU+Jj9R459m9Xs1mXwMnhi61ZkA.ch0p1Ot1p4xs0OuQtbK3UFZ2bsUS8ZMMZGBqtnQ5VoC8WosfU5kbXkxULwJ0KWnoPPlPFiXUgXQLjwt5sGTWUxcP65Ir8DmhphbIzKjVLUpbQH1nSjBaioQRMltkTIEYlcnhISoq40PaA4P5hacmIugRH3ldVx.8wqqPV8UXGPxvDY.jYoYtfmT7pyN2Eaz0TcoDtSgJSEFM5NdGoK3UVGykLdakasXsZfGUavNJZyWdwVm1YAkwBfxWhdhE+.rUaCH3HAnhDjy+aB6VqU+ZsFfdOpL+uRak41otx7KrZLTG8JSwzmG+6a2wQi6E5Mx9fchZLHOU.jQnc1b2PKH7WsAo9YCx0n1bKrir+McBpGHV+iUP5srcamsB+QgW.46qwcZFVWa3HuagcH0g0LtOXURSaNv2zH9BVoImKZPY0S5CNSgc3b6f74lwGe4FXWIyBYIawzsTsU4AbWWGxqdX7N2tNi6PBXqDW95dtBdynMfOmSY4b90vq9KnkVLmelW42qrN70B6dwztifcC98oQRsGqzSn0Qtzm3JdNj.D2xI7i.D2yrdY9zLq2dbOAb4tDV3PeMDZRRXCRq.jLBJkxMpPrv1yGwWnBgYNeTY2gcpGUIorS8nN6Rl0NdVqqiRUpy2c4m5rueSptYVUQe.RiNfIk54aR84HHp7NTHpMC7RxWsAYUG6t95T+MR6Td4IZsYKAZDWmjqNIpJ+YmS6QORSeo4FOKLjrQCf5mIn3QDlXVgiGYtGNd12bE7oqPWTOc0k5yUcEiwxY5JFFc3qCqdSdZsO1ghYhVa.erqEUdmbDZgCouJi54tjpXevJGvQfMMXv9BCpu.J1.r5LhuGhh585U09+zIJi6Bq9ggD5tPfxcBfxDHYsj9odBitEUao1SHv4XmNOW5L2BdOtpNXlqM2knGSyEhdrK23RO4LxmnJ6nYjP5FDgGKgpCEkXTRSwlfoPO98jHg4iywnLlkPYP6DZpjrRh1MCHITg.6byccM.Ci+E43bF7rbIufZJZDSuuMl37wEuE1wLIKEkyHK9odgKYHvXiuKApt1UlT5mmZfO+g8yjtKmmQn9rQXrBsosEoHDC1Bxs4iwogjY0vdVhHoIuSVhy31M3LZBOf8HPEr0qSR3X00MzpBANN+yYJrGwh.rVaK56JrCDWG6.1Ix.ZKzSusnWmW2EE.2fTc++3AFy7Ie9ndeCEhe9wyI8cPPL87Z9G2Ze3Oueevm8pGm47C4Leo+63H0bl+BztLqiSEo4+ouIM+sokz7CGxZdHq49g0b9grlGxZ9ieVyJevYMOVgyOq4293grlctJUS9PVyCYMOj07PVyCYMeUl076i0nI1vg+Ji.lOxfRi4KArsL++wHxhJIaqo24ulvlP5sWYXjTUcLw7C5DWXPm3hC5Du+fNwkFzI9fAchKe1STV8wpdBdyf6hPIYkKFvpQs0OzI0LJ+GnV8HWI

As you will see there are 2 voices we want to use Global modulators with, but one of them is listening to the Arp at the top of the tree, and one of them isnt...but because the global modulator (in this case a simple LFO) "hears" all the notes that arrive then its modulation is being applied even to the voice not listening to the Arp for every Arp note that is issued...

Im all ears for any alternative routing set up solution that gets past this problem and still leaves us with Global modulators that can be applied across voices...

ok: edit - I was being silly, so putting the arp after the Global modulator container does seem to work, but of course now notes responding to the arp -who also are connected to the LFO get no modulation info....essentially the opposite problem...

HiseSnippet 1845.3oc6a72SaaD0lvUQf1Nf1sVseH4Is+.ZqPwAJEVUUCDfVFjlHRJsR6OpNrujbBm67rOSKZpe21Gg8EXS8iv9Fr8NamDaRH3DRW4GI+QTt2c26d262umcJ4vMHttbGE0IqbrMQQ8lnxGyD0yWGSYJaugh5sQEvtBhiV.n0O1F65RLUTUS8BI.0ziq3+4ed95XKLyfzFjhx9bpAYWZCpnMzR41gZYsE1jTg1HxpWJ21FbVdtE2CnmTnLJ1XiCw0HuBKW1XHkWhcqqn9.T1pGXjs5SVbE8U0W8IKspt9iW4fkxj0v7wqt3hKunY0rqfWdEXS2XSSpf6TVfEDWE0wWmadb4572yBNf8otzCrHxA5JkgSN.7VbKS4UT9ak70oVlkZxnbU.jVpMaKU.a6tnBTSZK3sYeS6OgV6cDkApNVuHO8Aj7TiPdiGPdyfJa3PsEsmQRaSg1lAR1pXPlEkrBVqh5efxygEvDKz.eHYKGXPqML2xYx7HM3q4eZUOlgfxYZb1q3BRQ1byO4uOY5I+3jZmbppU65bxiwgaYQb55zR0Dmdsw4XdMNf37HsivVdjVKDt9w4u2HY7WifacjExYaynhh1jvwsk.5cQBnDx1fe85s2.KvRgRHLXc1DGAURNpaPNBLOBDQoQaPbOTvsACjNjefVD2zyBKhqZIM.Cm.3GwjgRAEykJNNpAZenukoq5ac81lPxcFTIpvnd2o2w5B8BbsO2zan06sPaVsJwPzlXGGs0aGTS0AiTlHfT9VzKr3GfsZy.A8FfpHAlr+P3zZslWq0Bz6gy4+LoNmsSryY0Tw4Hn904ktRwiHNGQIu+LbnM9W.+sCe8+6zgnycnZwNfQHlIfjQnc2pXHGD9UahT+rIx0o1bKrib9sbH+lGgYDY9GjSpMsMKpl2avGQpxcZD55KD98ysKoFblQWYERCaNjRhQzCrbCNWTmxpEWGUQYWN2dSFF3HlQAWpN1UF7wkHhBVh1J7fzaxawMNL5jaWiwcHAAzhBOumqf2n4EvOsjxBhsuad0eEs7RK.ep9P42qlG9ZwhCmwc3LLUxTE5h3erDqwJ0DZIxk5DWviwDPwsTBuDPw8LpXpqmQE2i6I.i6BXgC8CfqoW40nLD1wf.TBiQrjAaTGSZKFLNibruAMgY5O3egOgSpKGqFNodyI6Rj2Np74lnVgVyLLp6YXEZMyPLz5knRYZoUtliMoVMpzNJrB0HPhGt5jLxA1mY6T5UuSXQGvRE9TzsCKtZcOg.reolRPATQHH+xRhpdnj.bbKzdDHfUbTDnmepaurE0DxTTt8ux2rAhLEBqEBFOgHXJjb29zPebAhffo8QP4CocPBpIjE.Xf6H1gbb+yHieQrIDycX7CNIBtetNPvzgHHOuwA704evGEyhJGDRgzBbxtLQHiagJZHfzF1CypQ5e4YZT45dUqZQFLsooPA4EUgRNMRe7fMOarytDFRKRhf6BrfFzJbFIxDsvjzmpoeJPeGRe4E59m93r1m.4iAw8RzYU8gquFjszNa.YK4UJXbhOqYQ6RX0D0S1Icn7j1+WfS5s7RAiURlJzLnv.RkIVPPU9YYNzUjbOTQOgsm3TPUSUB8bIklJTZSv2nSSD1llFKwzzWIQxlLyNPwzIT07FnWBQA5hZ8n9fb8sOH8JaL8qpYigthzX4uFA0MuKEpqlA4wmsRcBjgVWaw7egzNk1GSqNWA.i3ZjEpQZ5eZt40d1yzzWd9ISCKIcyEP8qUeyifDzlS33Ql+oSl9iW.6+LZX0+4qS8b9LUEC8X78g8WSJs1G6PwLQqKfOsq0rAbxUnEtj9pQWu1kTA6SrxE.1zhfE6CLnCPigjRBFwWCQQ8Q8pes+7IZz1PqCOiBEMTHk6EPJSgjc6yObTn2slc+S6EDPN1oxym8duGTIQEGLy0l6Rzif4bMSS2MJzStirw5CZycDC5FDgGKFpCAk8jcxcKfUnG0NoIvHqbhbkvrXHCFGCSEj85o8vfxUJSfatYQWCfw3aHG4TJ4Y4RdC0TTOBd+TDvYiB9kXGy38QVYPeDFwcAFY8cFlW+hcSWNO4wd9CEjJYFrmg6+zMowxzF1VjMA+xVP7NeZbVH.WUrmknIz31oE3LtccNiFSqXOhvgVqFIlxVWuPqID3nO0f6laOnhLraDa2eJ2tfudrCvmHCHuPO47hdIutOJfbCB+c0nboTW6iQ0aKTvm5kGI88Pfe9rZ9hasu7x6+OdJDW7dRGYGUa8m6WhfyWs0eCpHy53DUb8e22EW+iIs35mNp55QUW2OUWmcT00ipt9xe00Jewqtdhbm+pq+zyGUc8E72VvQUWOp55QUWOp55QUWewt55qJmQCrgC+cFAUbIc7MgODP9w7+2WkFUPNVSuy2SiFPHz2YXDGUcrwrC5FWbP23RC5Fe7ftwkGzM9jAciqb1aTlgyZdBdi.6cHUvRaFTMkZqWUd0TJ+2lvuOu

d.healey

@d-healey said in Roadmap to HISE 5:

https://github.com/christophhart/HISE/pull/681
https://github.com/christophhart/HISE/pull/705
https://github.com/christophhart/HISE/pull/704

I've updated all of these now with the latest develop stuff - I think this means I merged the same things into each PR so there will be some duplication of effort in the last two commits.

I tested and all the functionality seems to be working as expected - the additional broadcasters are really nice :)

Lindon

So thinking about this some more - and Im not sure if this is in(Im guessing not) or even possible in the new system: ....

Modulation data is generated on note events (envelopes, LFO, velocity curves etc.). It would be very very useful if we had (possibly additional) modulator types that sent modulation data on channels that matched the midi channel of the note that triggered them, and "modulation receivers" (like the Global Time variant Modulators) that could be scripted to "listen" on specific channels....

It would add to the flexibility of the modulation system enormously...

griffinboy

@Christoph-Hart

Only reason I asked about oversampling is because then you can do phase warping at runtime : )

you could always update the default c++ node template with some commented out examples. I've done this myself to keep track of different features and their api

Or perhaps the hise docs could have some stuff written up for the c++ nodes? I think there is almost no detail on the docs

Orvillain

@Christoph-Hart said in Roadmap to HISE 5:

@Orvillain haha, I think you became victim of the worst UX in HISE, but since I crammed that feature in last minute I haven't spent too many brain cells on how to present that feature :)

You must not set the ID of the matrix modulator to the same string (the ID must always be unique), instead, you need to enter the ID you want to use for both matrixes in the hidden and unlabeled text editor that shows up when you click on "Edit range properties" next to the button. This will be set to the ID as a default value but if you change it there, it will override the matrix target ID that is otherwise taken from the module ID as default behaviour.

Yeah that's what I did!

Snippet is working on Windows here anyway. I think I must've just forgot to compile when I tried it for the first time.

Cheers!

Christoph Hart

@griffinboy yes good idea, and yes the C++ API documentation is seriously lacking, but one thing after the other.

I've just made a small example - a C++ node that wraps a pitch_mod node and a core::oscillator and then uses the API to pickup the pitch modulation from HISE and apply it to the oscillator frequency. This shows how to pickup modulation signals from HISE and use them however you like - using the core::extra_mod class works the exact same way.

This can be easily rewritten to a template that you can feed any sound generator type into to pickup the pitch modulation.

template <int NV> struct osc_with_pitchmod: public data::base
{
    // set this to false and this class will use audio rate pitch modulation instead of the downsampled resolution. 
    // This comes with a little overhead because it needs to resort to per frame processing in that case so it's disabled by default.
    static constexpr bool UseControlRate = true;
    
    // This can be any C++ oscillator class that follows the scriptnode API
    // The only requirement is that it must have a setPitchMultiplier() method
    // which will be used to set the pitch ratio accordingly.
    using OscillatorType = core::oscillator<NV>;
    
	SNEX_NODE(osc_with_pitchmod);
	
	struct MetadataClass
	{
		SN_NODE_ID("osc_with_pitchmod");
	};
	
	static constexpr bool isModNode() { return false; };
	static constexpr bool isPolyphonic() { return NV > 1; };
	static constexpr bool hasTail() { return true; };
	static constexpr bool isSuspendedOnSilence() { return false; };
	static constexpr int getFixChannelAmount() { return 2; };
	
	static constexpr int NumTables = 0;
	static constexpr int NumSliderPacks = 0;
	static constexpr int NumAudioFiles = 0;
	static constexpr int NumFilters = 0;
	static constexpr int NumDisplayBuffers = 0;
	
	// Scriptnode Callbacks ------------------------------------------------------------------------
	
    osc_with_pitchmod()
    {
        // we want the pitch mod to copy the pitch modulation values
        // to our temporary buffer so we can apply it to the oscillator
        pitchMod.setProcessSignal(true);
    }
    
    // now we just forward all callbacks to both objects
	void prepare(PrepareSpecs specs)
	{
        osc.prepare(specs);
        
        if(UseControlRate && specs.blockSize > 1)
        {
            specs.sampleRate /= HISE_CONTROL_RATE_DOWNSAMPLING_FACTOR;
            specs.blockSize /= HISE_CONTROL_RATE_DOWNSAMPLING_FACTOR;
        }

        pitchMod.prepare(specs);

        // make sure that the pitch mod buffer is initialised
        // to the correct size
        specs.numChannels = 1;
        FrameConverters::increaseBuffer(pitchSignal, specs);
	}
	
	void reset()
	{
        pitchMod.reset();
        osc.reset();
	}
	
	void handleHiseEvent(HiseEvent& e)
	{
        pitchMod.handleHiseEvent(e);
        osc.handleHiseEvent(e);
	}
	
	template <typename T> void process(T& data)
	{
        // create a ProcessData<1> object with our temp buffer
        // as data and feed that to the pitch mod so that it
        // copies the pitch modulation values coming from HISE
        // into our buffer
        float* pd[1] = { pitchSignal.begin() };
        
        auto numPitchSamples = data.getNumSamples();
        
        if constexpr (UseControlRate)
            numPitchSamples /= HISE_CONTROL_RATE_DOWNSAMPLING_FACTOR;
        
        ProcessData<1> pitchData(pd, numPitchSamples, 1);
        pitchMod.process(pitchData);
        
        if constexpr (UseControlRate)
        {
            // now we chunk the buffer into blocks of 8 (default control raster).
            // this is essentially the same as a container::fix_block<8> container.
            ChunkableProcessData<T, false> cd(data);
            int pitchIndex = 0;
            
            while(cd)
            {
                auto numToSlice = jmin(cd.getNumLeft(), HISE_CONTROL_RATE_DOWNSAMPLING_FACTOR);
                jassert(numToSlice == HISE_CONTROL_RATE_DOWNSAMPLING_FACTOR);
                auto sd = cd.getChunk(numToSlice);
                
                jassert(isPositiveAndBelow(pitchIndex, numPitchSamples));
                
                auto pitchRatio = pd[0][pitchIndex++];
                osc.setPitchMultiplier(pitchRatio);
                osc.process(sd.toData());
            }
        }
        else
        {
            // otherwise we use frame processing to iterate over each sample
            // and before calculating the next oscillator sample we
            // update the pitch ratio.
            auto fd = data.template as<ProcessData<2>>().toFrameData();
            
            int pitchIndex = 0;
            
            while(fd.next())
            {
                auto pitchRatio = pd[0][pitchIndex++];
                osc.setPitchMultiplier(pitchRatio);
                osc.processFrame(fd.toSpan());
            }
            
            // copy the left channel to the right one.
            data[1] = data[0];
        }
	}
	
	template <typename T> void processFrame(T& data)
	{
        span<float, 1> pd;
        pitchMod.processFrame(pd);
        osc.setPitchMultiplier(pd[0]);
        osc.processFrame(data);
	}
	
    //SN_EMPTY_HANDLE_MOD();
//    SN_EMPTY_SET_EXTERNAL_DATA();
    
    // now this is important: you need to define this method and forward it to any
    // member that connects to a HISE modulation chain for the pitch modulation to work!
    void connectToRuntimeTarget(bool addConnection, const runtime_target::connection& c)
    {
        pitchMod.connectToRuntimeTarget(addConnection, c);
    }

	template <int P> void setParameter(double v) {}
	void createParameters(ParameterDataList& data) {}
    
    // this is the pitch_mod node that picks up the pitch modulation from HISE
    core::pitch_mod<NV> pitchMod;
    
    // this is our oscillator. You can plugin any other class that has a
    // setPitchMultiplier method (where the pitch ratio is being applied.
    OscillatorType osc;
    
    // We'll "render" the pitch signal into a separate audio buffer
    heap<float> pitchSignal;
};

Roadmap to HISE 5

31

1.8k

12.1k

105.8k