afterpresets 0.2.0 → 0.3.0

package/template/native/src/License.cpp

@@ -0,0 +1,95 @@
+#include "License.h"
+
+#include <cstdio>
+#include <cstdlib>
+#include <string>
+
+#include "ap_effect_config.h" // generated: AP_BUNDLE_ID, AP_VERSION, AP_API_BASE, AP_PUBLIC_KEY, ...
+#include "ap_native.h"
+
+namespace license {
+namespace {
+
+// Process-wide; set and cleared on the main thread only (GLOBAL_SETUP /
+// GLOBAL_SETDOWN), read-only while frames render.
+ap_runtime *g_ap = nullptr; // ap-check: allow mfr_global (written only in GLOBAL_SETUP/SETDOWN)
+bool g_enforce = true;      // ap-check: allow mfr_global (written only in GLOBAL_SETUP)
+
+void copy(char *out, std::size_t size, const char *text) {
+  if (size) std::snprintf(out, size, "%s", text);
+}
+
+// Dev builds render without the watermark so you can test the look. To see
+// the locked state in a dev build, create the file
+// ~/.afterpresets/native-dev-enforce-license (or start After Effects with
+// AP_DEV_ENFORCE_LICENSE=1) and restart After Effects. Release builds always enforce.
+bool dev_enforce_requested() {
+  if (std::getenv("AP_DEV_ENFORCE_LICENSE")) return true;
+#ifdef _WIN32
+  const char *home = std::getenv("USERPROFILE");
+#else
+  const char *home = std::getenv("HOME");
+#endif
+  if (!home) return false;
+  std::string flag = std::string(home) + "/.afterpresets/native-dev-enforce-license";
+  FILE *f = std::fopen(flag.c_str(), "rb");
+  if (f) std::fclose(f);
+  return f != nullptr;
+}
+
+} // namespace
+
+void start() {
+  if (g_ap) return;
+  ap_config c;
+  ap_config_defaults(&c);
+  c.bundle_id = AP_BUNDLE_ID;
+  c.version = AP_VERSION;
+  c.api_base = AP_API_BASE;
+  c.public_key = AP_PUBLIC_KEY; // Ed25519 public key: verifies, cannot sign
+  c.product_url = AP_PRODUCT_URL[0] ? AP_PRODUCT_URL : nullptr;
+  c.manage_devices_url = AP_MANAGE_DEVICES_URL[0] ? AP_MANAGE_DEVICES_URL : nullptr;
+  c.license_enabled = AP_LICENSE_ENABLED;
+  c.offline_grace_days = AP_OFFLINE_GRACE_DAYS;
+  c.check_in_background = AP_CHECK_IN_BACKGROUND;
+  c.update_mode = AP_UPDATE_MODE;
+  c.dev = AP_DEV_BUILD;     // dev builds never install updates
+  c.build_id = AP_BUILD_ID; // logged at start; `ap dev` reads it to know which build is loaded
+  g_ap = ap_init(&c);       // NULL (config error): stays locked, never crashes
+  g_enforce = AP_LICENSE_ENABLED && (!AP_DEV_BUILD || dev_enforce_requested());
+  ap_apply_staged_update(g_ap); // an update staged in an earlier session
+}
+
+void stop() {
+  ap_log(g_ap, 1, "global setdown"); // lets tools confirm After Effects shut the effect down cleanly
+  ap_apply_staged_update(g_ap); // usually a no-op: updates apply right after download
+  ap_shutdown(g_ap);
+  g_ap = nullptr;
+}
+
+bool unlocked() {
+  if (!g_enforce) return true;
+  return ap_is_unlocked(g_ap) != 0; // NULL runtime: locked
+}
+
+void options_dialog() { ap_options_dialog(g_ap, AP_EFFECT_NAME); }
+
+void status_name(char *out, std::size_t size) {
+  char notice[256] = "";
+  if (g_ap && ap_update_notice(g_ap, notice, sizeof notice) && notice[0]) return copy(out, size, "Update: restart AE");
+  if (!AP_LICENSE_ENABLED) return copy(out, size, "AfterPresets");
+  if (!g_ap) return copy(out, size, "License: unavailable");
+  switch (ap_status_get(g_ap)) {
+  case AP_STATUS_DISABLED: return copy(out, size, "AfterPresets");
+  case AP_STATUS_ACTIVE: return copy(out, size, "License: active");
+  case AP_STATUS_OFFLINE_GRACE: return copy(out, size, "License: offline");
+  case AP_STATUS_SIGNING_IN: return copy(out, size, "License: signing in");
+  case AP_STATUS_CHECKING: return copy(out, size, "License: checking");
+  case AP_STATUS_SIGNED_OUT: return copy(out, size, "License: sign in");
+  default: return copy(out, size, "License: see Options");
+  }
+}
+
+const char *button_label() { return AP_LICENSE_ENABLED ? "License..." : "About..."; }
+
+} // namespace license

package/template/native/src/License.h

@@ -0,0 +1,29 @@
+// Glue between the effect and the AfterPresets runtime (ap_native): license
+// state, the Options dialog, the update notice. Keep this file: it is how
+// buyers sign in and how updates reach them. `ap docs` has the details.
+#pragma once
+
+#include <cstddef>
+
+namespace license {
+
+// PF_Cmd_GLOBAL_SETUP / PF_Cmd_GLOBAL_SETDOWN (main thread).
+void start();
+void stop();
+
+// Any thread, including render threads (lock-free): true when the frame
+// renders without the watermark. Read it once per frame in PreRender.
+bool unlocked();
+
+// Effect > Options, or the status button (main thread). Shows the
+// AfterPresets dialog: license state, Sign in / Buy / Sign out, update notice.
+void options_dialog();
+
+// Short text for the status button's name (at most 31 bytes), e.g.
+// "License: active" or "Update: restart AE". UI thread.
+void status_name(char *out, std::size_t size);
+
+// Caption on the status button.
+const char *button_label();
+
+} // namespace license

package/template/native/src/Render.h

@@ -0,0 +1,68 @@
+// Pixel work for the starter effect: tint toward a colour, blended by mode,
+// optionally along a gradient (centre + angle). One template serves 8, 16 and
+// 32 bits per channel. Pure functions of their inputs, so they are safe for
+// multi-frame rendering (After Effects renders several frames at once).
+#pragma once
+
+#include <cmath>
+#include <cstddef>
+
+struct TintParams {
+  float amount;        // 0..1
+  float r, g, b;       // 0..1
+  int mode;            // AP_MODE_* (1-based popup value)
+  bool gradient;       // fade the tint across the layer
+  float cx, cy;        // gradient centre, in the pixels of the buffers below
+  float dirx, diry;    // unit vector the tint grows along
+  float span;          // pixels over which the gradient goes from 0 to full
+  bool watermark;      // not licensed: draw stripes
+};
+
+template <typename T> inline T clampv(T v, T lo, T hi) { return v < lo ? lo : (v > hi ? hi : v); }
+
+// Premultiplied colour channel blend. s, c in 0..1 (s premultiplied by a).
+inline float blend(int mode, float s, float c, float a) {
+  switch (mode) {
+  case 2: return s + c * a - s * c;  // Screen
+  case 3: return s * c;              // Multiply
+  default: return c * a;             // Tint
+  }
+}
+
+// PixelT: PF_Pixel / PF_Pixel16 / PF_PixelFloat. MAXV: 255, 32768 or 1 (float, unclamped).
+template <typename PixelT, int MAXV, bool FLOAT>
+void tint_rows(const char *src, long src_rowbytes, char *dst, long dst_rowbytes, int width, int height,
+               const TintParams &p) {
+  const float scale = FLOAT ? 1.f : (float)MAXV;
+  for (int y = 0; y < height; ++y) {
+    const PixelT *s = (const PixelT *)(src + (std::ptrdiff_t)y * src_rowbytes);
+    PixelT *d = (PixelT *)(dst + (std::ptrdiff_t)y * dst_rowbytes);
+    for (int x = 0; x < width; ++x) {
+      const float a = s[x].alpha / scale;
+      const float sr = s[x].red / scale, sg = s[x].green / scale, sb = s[x].blue / scale;
+      float t = p.amount;
+      if (p.gradient) {
+        const float along = ((float)x - p.cx) * p.dirx + ((float)y - p.cy) * p.diry;
+        t *= clampv(0.5f + along / p.span, 0.f, 1.f);
+      }
+      float r = sr + (blend(p.mode, sr, p.r, a) - sr) * t;
+      float g = sg + (blend(p.mode, sg, p.g, a) - sg) * t;
+      float b = sb + (blend(p.mode, sb, p.b, a) - sb) * t;
+      if (p.watermark && (((x + y) / 24) & 1)) {
+        r = r * 0.5f + 0.25f * a;
+        g = g * 0.5f + 0.25f * a;
+        b = b * 0.5f + 0.25f * a;
+      }
+      d[x].alpha = s[x].alpha;
+      if (FLOAT) {
+        d[x].red = (decltype(d[x].red))r;
+        d[x].green = (decltype(d[x].green))g;
+        d[x].blue = (decltype(d[x].blue))b;
+      } else {
+        d[x].red = (decltype(d[x].red))clampv(r * scale + 0.5f, 0.f, scale);
+        d[x].green = (decltype(d[x].green))clampv(g * scale + 0.5f, 0.f, scale);
+        d[x].blue = (decltype(d[x].blue))clampv(b * scale + 0.5f, 0.f, scale);
+      }
+    }
+  }
+}