daniel
66d47fb410
Extension stamps a monotonic bank_generation counter, bumped at content mutations; the VST3 instrument polls it off-thread on an editor timer and consumes assignment requests, refreshing playback hands-free.
113 lines
6.2 KiB
C++
113 lines
6.2 KiB
C++
// reasampler_embed.h — the S6 embedded TCP/MCP UI shell. Implements REAPER's
|
|
// IReaperUIEmbedInterface (vendor/reaper-sdk/sdk/reaper_plugin_fx_embed.h +
|
|
// reaper_vst3_interfaces.h) so the instrument draws a compact keymap/level strip INLINE in
|
|
// the track/mixer control panel — the same Cockos surface REAPER's own embedded FX use.
|
|
//
|
|
// VERIFIED CONTRACT (against reaper_plugin_fx_embed.h + reaper_vst3_interfaces.h):
|
|
// * VST3 exposes this by having the IEditController answer queryInterface for
|
|
// IReaperUIEmbedInterface (iid {0x049bf9e7,0xbc74ead0,0xc4101e86,0x7f725981}). Our
|
|
// SingleComponentEffect IS the edit controller, so the processor's queryInterface hands
|
|
// REAPER a reference to this object.
|
|
// * The single method is embed_message(int msg, TPtrInt parm2, TPtrInt parm3). msg is a
|
|
// REAPER_FXEMBED_WM_* value (aliased to Win32 WM_*):
|
|
// - WM_IS_SUPPORTED (0x0000): return 1 (supported+available), -1, or 0.
|
|
// - WM_CREATE (0x0001) / WM_DESTROY (0x0002): embed begin/end; return ignored.
|
|
// - WM_PAINT (0x000F): parm2 = REAPER_FXEMBED_IBitmap* (alias LICE_IBitmap) to draw
|
|
// into; parm3 = REAPER_FXEMBED_DrawInfo* (context TCP=1/MCP=2, width/height, mouse,
|
|
// flags). Return 1 if drawing occurred, 0 otherwise.
|
|
// - WM_GETMINMAXINFO (0x0024): parm3 = SizeHints*; return 1 if filled.
|
|
// - mouse WM_* (0x0200..0x020A): parm3 = DrawInfo*; return RETNOTIFY_INVALIDATE
|
|
// (0x1000000) to force a redraw. Capture is auto-managed by the host.
|
|
// * There is NO plugin-owned window/HWND here (unlike the IPlugView editor): REAPER hands
|
|
// a LICE bitmap per paint; we only draw into it and read mouse coords from DrawInfo.
|
|
//
|
|
// RT DISCIPLINE (S6 constraint): all embed messages arrive on REAPER's UI thread; nothing
|
|
// here runs in process(). It reads the same live state the editor reads (bank over the
|
|
// bridge + the processor's performance map) with the same off-audio-thread accessors — no
|
|
// new locks visible to process, read-only over the bank. Windows-only (D5), guarded so a
|
|
// non-Windows build stays compilable.
|
|
//
|
|
// The strip's LAYOUT + HIT-TEST is pure (embed_strip.h, unit-tested); this shell marshals
|
|
// REAPER's messages to/from it and draws with the same LICE idiom as reasampler_editor.
|
|
|
|
#pragma once
|
|
|
|
#include <cstdint>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "pluginterfaces/base/funknown.h"
|
|
|
|
#include "sample_map.h" // SampleChoice, PerformanceMap (the state the strip reflects)
|
|
|
|
// REAPER's VST3-side embed interface (vendored). Uses UNQUALIFIED Steinberg types, so it is
|
|
// pulled into the Steinberg namespace the same way reaper_bridge.cpp includes the host
|
|
// interface header. Its iid is DEFINEd (DEF_CLASS_IID) in reasampler_embed.cpp.
|
|
namespace Steinberg {
|
|
#include "reaper_vst3_interfaces.h"
|
|
} // namespace Steinberg
|
|
|
|
namespace reasampler::vst {
|
|
|
|
class ReaSamplerProcessor;
|
|
|
|
// Implements IReaperUIEmbedInterface. Lifetime is OWNED by the processor (the processor
|
|
// holds the sole unique_ptr and hands out AddRef'd references from queryInterface); the
|
|
// back-pointer to the processor is therefore always valid while this lives.
|
|
class ReaSamplerEmbed : public Steinberg::IReaperUIEmbedInterface {
|
|
public:
|
|
explicit ReaSamplerEmbed(ReaSamplerProcessor* processor) : processor_(processor) {}
|
|
|
|
// The one embed entry point. Routes each REAPER_FXEMBED_WM_* message; see the header
|
|
// note above for the per-message contract. UI thread only.
|
|
Steinberg::TPtrInt embed_message(int msg, Steinberg::TPtrInt parm2,
|
|
Steinberg::TPtrInt parm3) override;
|
|
|
|
// FUnknown: this object's lifetime is owned by the processor, not the host refcount, so
|
|
// AddRef/release are no-ops (the processor's unique_ptr governs destruction) and
|
|
// queryInterface answers only FUnknown + IReaperUIEmbedInterface. This mirrors how the
|
|
// SDK's OBJ refcount would otherwise churn; here the owning processor guarantees the
|
|
// object outlives every borrowed reference REAPER holds during embedding.
|
|
Steinberg::tresult PLUGIN_API queryInterface(const Steinberg::TUID iid,
|
|
void** obj) override;
|
|
Steinberg::uint32 PLUGIN_API addRef() override { return 1000; }
|
|
Steinberg::uint32 PLUGIN_API release() override { return 1000; }
|
|
|
|
private:
|
|
#ifdef _WIN32
|
|
// Draw the current strip into REAPER's supplied LICE bitmap. Returns true if it drew.
|
|
bool paint(Steinberg::TPtrInt bitmap, Steinberg::TPtrInt drawInfo);
|
|
// Handle a mouse-down inside the strip: map to a zone and select it (S6: selection at
|
|
// most — no new editing semantics). Returns true if the selection changed (the caller
|
|
// then asks REAPER to invalidate).
|
|
bool onMouseDown(Steinberg::TPtrInt drawInfo);
|
|
#endif
|
|
|
|
// Snapshot the live bank + the instrument's performance map for the next paint, exactly
|
|
// as the editor's refreshSampleList does (bridge read + processor accessors, UI thread).
|
|
void refresh();
|
|
|
|
// The S9 dirty-guard over refresh() (the S6 flagged follow-up): read the cheap bank-
|
|
// generation stamp; do the EXPENSIVE bank-blob bridge read (refresh()) only when the
|
|
// generation changed since the last paint (or on the first paint) — the strip re-read
|
|
// per paint was wasteful now that a generation counter exists. The performance map (a
|
|
// cheap in-process accessor, edited by the editor independently of bank content) is
|
|
// ALWAYS refreshed so a zone edit still reflects immediately. UI thread only.
|
|
void maybeRefresh();
|
|
|
|
ReaSamplerProcessor* processor_ = nullptr;
|
|
// The bank generation last folded into samples_ (S9 dirty-guard). -1 forces the first
|
|
// maybeRefresh() to do a full read (no generation can be negative — parseBankGeneration
|
|
// yields >= 0 — so -1 is an "unprimed" sentinel distinct from a real generation 0).
|
|
std::int64_t lastSeenBankGeneration_ = -1;
|
|
// Snapshotted for the current paint (refreshed each paint off the audio thread).
|
|
std::vector<SampleChoice> samples_;
|
|
PerformanceMap map_;
|
|
// The zone the last click selected (local/visual only — S6 selection constraint; the
|
|
// processor's editor-shared selection is NOT updated from here); -1 = none.
|
|
// Drives the strip's highlight.
|
|
int selectedZone_ = -1;
|
|
};
|
|
|
|
} // namespace reasampler::vst
|