Q-W1 pt2: core/shell/app relocation + sub-namespaces; one concrete ui::Rect (LTRB fork retired); slot_map split from bank_book; BankIndex→BankModel; 59/59 green

2026-07-28 20:48:56 -04:00
parent 67a41728f3
commit 847936f813
222 changed files with 2247 additions and 2079 deletions
@@ -0,0 +1,84 @@
+#include "core/namespaces.h"
+// vst_entry.cpp — the VST3 module class factory (Phase S1). Enumerates the one class
+// this module offers (the ReaSampler instrument) via the SDK's factory macros. The
+// Windows module exports — GetPluginFactory (here, via BEGIN_FACTORY) and
+// InitDll/ExitDll (from the SDK's dllmain.cpp) — are how REAPER discovers and loads a
+// VST3.
+//
+// VERIFIED (corrects §1a's "experienced estimate" flags on export names + macros,
+// against vendor/vst3sdk/public.sdk/source/main/):
+//   * Windows exports: InitDll / ExitDll (SMTG_EXPORT_SYMBOL, in dllmain.cpp) +
+//     GetPluginFactory (SMTG_EXPORT_SYMBOL IPluginFactory* PLUGIN_API, emitted by the
+//     BEGIN_FACTORY macro). The plug-in must provide InitModule/DeinitModule — supplied
+//     here by linking moduleinit.cpp (the SDK's default one-time init/term).
+//   * Factory macros: BEGIN_FACTORY(vendor,url,email,flags) / DEF_CLASS2(...) /
+//     END_FACTORY — exact spellings from pluginfactory.h.
+//   * Instrument subcategory string: "Instrument|Synth|Sampler"
+//     (PlugType::kInstrumentSynthSampler, ivstaudioprocessor.h).
+//   * classFlags = 0 for a SingleComponentEffect (non-distributable), matching the
+//     AGain example.
+
+#include "public.sdk/source/main/pluginfactory.h"
+
+#include "pluginterfaces/vst/ivstaudioprocessor.h"  // kVstAudioEffectClass, PlugType
+
+#include "core/version/app_version.h"       // vstPluginName / appVersion — the channel-derived identity
+#include "ext_keys.h"          // kProjExtNamespace — the pairing-surface assertion target
+#include "reasampler_processor.h"
+#include "shell/instrument/reasampler_vst.h"    // channel-selected class UID (REASAMPLER_ACTIVE_UID_*)
+
+// CHANNEL PAIRING INVARIANT (S18). The instrument's PLUGIN identity forks by the ONE channel
+// bit (REASAMPLER_CHANNEL_IS_BETA — the class UID selected in reasampler_vst.h, the filename
+// + display name in app_version). Its DATA identity forks by the SAME bit, one layer down:
+// ext_keys.h's kProjExtNamespace() delegates to app_version::extStateNamespace(), so a beta
+// binary reads "reasampler_beta". Both derive from that one bit, so a beta VST can only ever
+// talk to the beta extension.
+//
+// The guard below pins the two forks together so a refactor cannot split them. It asserts
+// that the CLASS UID this factory registers (REASAMPLER_ACTIVE_UID_1, selected by the #if in
+// reasampler_vst.h) is the UID that matches THIS binary's channel bit. If someone edited that
+// #if to pick the wrong branch — registering the stable UID in a beta build, or vice versa —
+// the instrument's identity would diverge from the namespace ext_keys reads (a beta-named
+// plugin presenting the stable UID, or reading the stable banks under a beta identity). That
+// is exactly the silent split the invariant forbids, and it breaks the build here instead.
+// (The namespace itself is a runtime accessor — .c_str() on a channel-selected string — so
+// the couplable compile-time fact is the UID selection, not the namespace value; the
+// app_version_tests pin the namespace string per channel.)
+#if REASAMPLER_CHANNEL_IS_BETA
+static_assert(REASAMPLER_ACTIVE_UID_1 == REASAMPLER_PROC_UID_BETA_1 &&
+              REASAMPLER_ACTIVE_UID_2 == REASAMPLER_PROC_UID_BETA_2 &&
+              REASAMPLER_ACTIVE_UID_3 == REASAMPLER_PROC_UID_BETA_3 &&
+              REASAMPLER_ACTIVE_UID_4 == REASAMPLER_PROC_UID_BETA_4,
+              "S18: a beta build must register the BETA class UID that pairs with the beta "
+              "extension's ext-state namespace — the UID selection and the channel bit split");
+#else
+static_assert(REASAMPLER_ACTIVE_UID_1 == REASAMPLER_PROC_UID_1 &&
+              REASAMPLER_ACTIVE_UID_2 == REASAMPLER_PROC_UID_2 &&
+              REASAMPLER_ACTIVE_UID_3 == REASAMPLER_PROC_UID_3 &&
+              REASAMPLER_ACTIVE_UID_4 == REASAMPLER_PROC_UID_4,
+              "S18: a stable build must register the STABLE class UID that pairs with the "
+              "stable ext-state namespace — the UID selection and the channel bit split");
+#endif
+
+BEGIN_FACTORY(reasampler::vst::kVendorName, reasampler::vst::kVendorUrl,
+              reasampler::vst::kVendorEmail, Steinberg::PFactoryInfo::kNoFlags)
+
+// The display name and version are channel-derived from app_version — sourced here, not
+// as literals. DEF_CLASS2 expands inside GetPluginFactory() and PClassInfo2's constructor
+// copies the char* into its own fixed buffer at that runtime call, so .c_str() on the
+// accessors' static-storage strings is valid (no dangling — the refs outlive the copy).
+// vstPluginName(): "ReaSampler 9000" / "ReaSampler 9000 beta" (live literals in
+// app_version.cpp). appVersion(): the configured version string / that string plus
+// "-beta" (the -beta render V4 already yields on beta).
+DEF_CLASS2(INLINE_UID(REASAMPLER_ACTIVE_UID_1, REASAMPLER_ACTIVE_UID_2,
+                      REASAMPLER_ACTIVE_UID_3, REASAMPLER_ACTIVE_UID_4),
+           Steinberg::PClassInfo::kManyInstances,       // cardinality
+           kVstAudioEffectClass,                        // component category (fixed)
+           reasampler::vstPluginName().c_str(),         // plug-in display name (channel-derived)
+           0,                                           // single-component => 0
+           Steinberg::Vst::PlugType::kInstrumentSynthSampler,  // subcategory
+           reasampler::appVersion().c_str(),            // plug-in version (channel: -beta render)
+           kVstVersionString,                           // VST3 SDK version (fixed)
+           reasampler::vst::ReaSamplerProcessor::createInstance)
+
+END_FACTORY