rngine 0.8.0 → 0.8.2

package/shared/skia/include/ports/SkFontMgr_FontConfigInterface.h

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkFontMgr_FontConfigInterface_DEFINED
+#define SkFontMgr_FontConfigInterface_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+
+#include <memory>
+
+class SkFontMgr;
+class SkFontConfigInterface;
+class SkFontScanner;
+
+/** Creates a SkFontMgr which wraps a SkFontConfigInterface. */
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_FCI(sk_sp<SkFontConfigInterface> fci,
+                                          std::unique_ptr<SkFontScanner> scanner);
+
+#endif // #ifndef SkFontMgr_FontConfigInterface_DEFINED

package/shared/skia/include/ports/SkFontMgr_Fontations.h

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkFontMgr_fontations_DEFINED
+#define SkFontMgr_fontations_DEFINED
+
+#include "include/core/SkRefCnt.h"
+
+class SkFontMgr;
+
+/** Create a font manager instantiating fonts using the Rust Fontations backend.
+ * This font manager does not support matching fonts, only instantiation.
+ */
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_Fontations_Empty();
+
+#endif // #ifndef SkFontMgr_fontations_DEFINED

package/shared/skia/include/ports/SkFontMgr_android.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkFontMgr_android_DEFINED
+#define SkFontMgr_android_DEFINED
+
+#include "include/core/SkRefCnt.h"
+
+#include <memory>
+
+class SkFontMgr;
+class SkFontScanner;
+
+struct SkFontMgr_Android_CustomFonts {
+    /** When specifying custom fonts, indicates how to use system fonts. */
+    enum SystemFontUse {
+        kOnlyCustom, /** Use only custom fonts. NDK compliant. */
+        kPreferCustom, /** Use custom fonts before system fonts. */
+        kPreferSystem /** Use system fonts before custom fonts. */
+    };
+    /** Whether or not to use system fonts. */
+    SystemFontUse fSystemFontUse;
+
+    /** Base path to resolve relative font file names. If a directory, should end with '/'. */
+    const char* fBasePath;
+
+    /** Optional custom configuration file to use. */
+    const char* fFontsXml;
+
+    /** Optional custom configuration file for fonts which provide fallback.
+     *  In the new style (version > 21) fontsXml format is used, this should be NULL.
+     */
+    const char* fFallbackFontsXml;
+
+    /** Optional custom flag. If set to true the SkFontMgr will acquire all requisite
+     *  system IO resources on initialization.
+     */
+    bool fIsolated;
+};
+
+/** Create a font manager for Android. If 'custom' is NULL, use only system fonts. */
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_Android(const SkFontMgr_Android_CustomFonts* custom,
+                                              std::unique_ptr<SkFontScanner> scanner);
+#endif // SkFontMgr_android_DEFINED

package/shared/skia/include/ports/SkFontMgr_android_ndk.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkFontMgr_android_ndk_DEFINED
+#define SkFontMgr_android_ndk_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+
+#include <memory>
+
+class SkFontMgr;
+class SkFontScanner;
+
+/** Create a font manager for Android NDK. May return nullptr if unavailable (API < 29).
+
+    The Android NDK Font API only works correctly in an Android Application process.
+    If running in a bare executable (for testing or the like) it will use the legacy fonts.xml data.
+ */
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_AndroidNDK(bool cacheFontFiles,
+                                                 std::unique_ptr<SkFontScanner> scanner);
+
+#endif // SkFontMgr_android_ndk_DEFINED

package/shared/skia/include/ports/SkFontMgr_data.h

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkFontMgr_data_DEFINED
+#define SkFontMgr_data_DEFINED
+
+#include "include/core/SkData.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSpan.h"
+#include "include/core/SkTypes.h"
+
+class SkFontMgr;
+
+/** Create a custom font manager which wraps a collection of SkData-stored fonts.
+ *  This font manager uses FreeType for rendering.
+ */
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_Custom_Data(SkSpan<sk_sp<SkData>>);
+
+#endif // SkFontMgr_data_DEFINED

package/shared/skia/include/ports/SkFontMgr_directory.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkFontMgr_directory_DEFINED
+#define SkFontMgr_directory_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+
+class SkFontMgr;
+
+/** Create a custom font manager which scans a given directory for font files.
+ *  This font manager uses FreeType for rendering.
+ */
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_Custom_Directory(const char* dir);
+
+#endif // SkFontMgr_directory_DEFINED

package/shared/skia/include/ports/SkFontMgr_empty.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkFontMgr_empty_DEFINED
+#define SkFontMgr_empty_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+
+class SkFontMgr;
+
+/** Create a custom font manager that contains no built-in fonts.
+ *  This font manager uses FreeType for rendering.
+ */
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_Custom_Empty();
+
+#endif // SkFontMgr_empty_DEFINED

package/shared/skia/include/ports/SkFontMgr_fontconfig.h

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkFontMgr_fontconfig_DEFINED
+#define SkFontMgr_fontconfig_DEFINED
+
+#include <fontconfig/fontconfig.h>
+#include "include/core/SkRefCnt.h"
+#include <memory>
+
+class SkFontMgr;
+
+/** Create a font manager around a FontConfig instance.
+ *  If 'fc' is NULL, will use a new default config.
+ *  Takes ownership of 'fc' and will call FcConfigDestroy on it.
+ */
+class SkFontScanner;
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_FontConfig(FcConfig* fc, std::unique_ptr<SkFontScanner> scanner);
+
+#endif // #ifndef SkFontMgr_fontconfig_DEFINED

package/shared/skia/include/ports/SkFontMgr_fuchsia.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2018 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkFontMgr_fuchsia_DEFINED
+#define SkFontMgr_fuchsia_DEFINED
+
+#include <fuchsia/fonts/cpp/fidl.h>
+
+#include "include/core/SkRefCnt.h"
+#include <memory>
+
+class SkFontMgr;
+class SkFontScanner;
+
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_Fuchsia(fuchsia::fonts::ProviderSyncPtr provider, std::unique_ptr<SkFontScanner> scanner);
+
+#endif  // SkFontMgr_fuchsia_DEFINED

package/shared/skia/include/ports/SkFontMgr_mac_ct.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2017 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkFontMgr_mac_ct_DEFINED
+#define SkFontMgr_mac_ct_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+
+#ifdef SK_BUILD_FOR_MAC
+#import <ApplicationServices/ApplicationServices.h>
+#endif
+
+#ifdef SK_BUILD_FOR_IOS
+#include <CoreText/CoreText.h>
+#endif
+
+class SkFontMgr;
+
+/** Create a font manager for CoreText. If the collection is nullptr the system default will be used. */
+SK_API extern sk_sp<SkFontMgr> SkFontMgr_New_CoreText(CTFontCollectionRef);
+
+#endif // SkFontMgr_mac_ct_DEFINED

package/shared/skia/include/ports/SkFontScanner_Fontations.h

@@ -0,0 +1,15 @@
+/*
+* Copyright 2024 Google LLC
+*
+* Use of this source code is governed by a BSD-style license that can be
+* found in the LICENSE file.
+*/
+
+#ifndef SKFONTSCANNER_FONTATIONS_H_
+#define SKFONTSCANNER_FONTATIONS_H_
+
+#include "include/core/SkFontScanner.h"
+
+SK_API std::unique_ptr<SkFontScanner> SkFontScanner_Make_Fontations();
+
+#endif // SKFONTSCANNER_FONTATIONS_H_

package/shared/skia/include/ports/SkFontScanner_FreeType.h

@@ -0,0 +1,15 @@
+/*
+* Copyright 2024 Google LLC
+*
+* Use of this source code is governed by a BSD-style license that can be
+* found in the LICENSE file.
+*/
+
+#ifndef SKFONTSCANNER_FREETYPE_H_
+#define SKFONTSCANNER_FREETYPE_H_
+
+#include "include/core/SkFontScanner.h"
+
+SK_API std::unique_ptr<SkFontScanner> SkFontScanner_Make_FreeType();
+
+#endif // SKFONTSCANNER_FREETYPE_H_

package/shared/skia/include/ports/SkImageGeneratorCG.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkImageGeneratorCG_DEFINED
+#define SkImageGeneratorCG_DEFINED
+
+// This is needed as clients may override the target platform
+// using SkUserConfig
+#include "include/private/SkLoadUserConfig.h"
+
+#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
+
+#include "include/core/SkData.h"
+#include "include/core/SkImageGenerator.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+
+#include <memory>
+
+namespace SkImageGeneratorCG {
+SK_API std::unique_ptr<SkImageGenerator> MakeFromEncodedCG(sk_sp<const SkData>);
+}  // namespace SkImageGeneratorCG
+
+#endif  // defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
+#endif  // SkImageGeneratorCG_DEFINED

package/shared/skia/include/ports/SkImageGeneratorNDK.h

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkImageGeneratorNDK_DEFINED
+#define SkImageGeneratorNDK_DEFINED
+
+#include "include/core/SkTypes.h"
+#ifdef SK_ENABLE_NDK_IMAGES
+
+#include "include/core/SkData.h"
+#include "include/core/SkImageGenerator.h"
+
+#include <memory>
+
+namespace SkImageGeneratorNDK {
+/**
+ *  Create a generator that uses the Android NDK's APIs for decoding images.
+ *
+ *  Only supported on devices where __ANDROID_API__ >= 30.
+ *
+ *  As with SkCodec, the SkColorSpace passed to getPixels() determines the
+ *  type of color space transformations to apply. A null SkColorSpace means to
+ *  apply none.
+ *
+ *  A note on scaling: Calling getPixels() on the resulting SkImageGenerator
+ *  with dimensions that do not match getInfo() requests a scale. For WebP
+ *  files, dimensions smaller than those of getInfo are supported. For Jpeg
+ *  files, dimensions of 1/2, 1/4, and 1/8 are supported. TODO: Provide an
+ *  API like SkCodecImageGenerator::getScaledDimensions() to report which
+ *  dimensions are supported?
+ */
+SK_API std::unique_ptr<SkImageGenerator> MakeFromEncodedNDK(sk_sp<const SkData>);
+}
+
+#endif // SK_ENABLE_NDK_IMAGES
+#endif // SkImageGeneratorNDK_DEFINED

package/shared/skia/include/ports/SkImageGeneratorWIC.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkImageGeneratorWIC_DEFINED
+#define SkImageGeneratorWIC_DEFINED
+
+#include "include/private/SkFeatures.h"
+
+#if defined(SK_BUILD_FOR_WIN)
+
+#include "include/core/SkData.h"
+#include "include/core/SkImageGenerator.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+
+#include <memory>
+
+/*
+ * Any Windows program that uses COM must initialize the COM library by calling
+ * the CoInitializeEx function.  In addition, each thread that uses a COM
+ * interface must make a separate call to this function.
+ *
+ * For every successful call to CoInitializeEx, the thread must call
+ * CoUninitialize before it exits.
+ *
+ * SkImageGeneratorWIC requires the COM library and leaves it to the client to
+ * initialize COM for their application.
+ *
+ * For more information on initializing COM, please see:
+ * https://msdn.microsoft.com/en-us/library/windows/desktop/ff485844.aspx
+ */
+namespace SkImageGeneratorWIC {
+SK_API std::unique_ptr<SkImageGenerator> MakeFromEncodedWIC(sk_sp<const SkData>);
+}
+
+#endif  // SK_BUILD_FOR_WIN
+#endif  // SkImageGeneratorWIC_DEFINED

package/shared/skia/include/ports/SkTypeface_fontations.h

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkTypeface_fontations_DEFINED
+#define SkTypeface_fontations_DEFINED
+
+#include "include/core/SkFontArguments.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypeface.h"
+#include "include/core/SkTypes.h"
+
+#include <memory>
+
+SK_API sk_sp<SkTypeface> SkTypeface_Make_Fontations(std::unique_ptr<SkStreamAsset> fontData,
+                                                    const SkFontArguments& args);
+
+SK_API sk_sp<SkTypeface> SkTypeface_Make_Fontations(sk_sp<const SkData> fontData,
+                                                    const SkFontArguments& args);
+
+#endif

package/shared/skia/include/ports/SkTypeface_mac.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkTypeface_mac_DEFINED
+#define SkTypeface_mac_DEFINED
+
+#include "include/core/SkTypeface.h"
+
+#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
+
+#include <CoreFoundation/CoreFoundation.h>
+
+#ifdef SK_BUILD_FOR_MAC
+#import <ApplicationServices/ApplicationServices.h>
+#endif
+
+#ifdef SK_BUILD_FOR_IOS
+#include <CoreText/CoreText.h>
+#endif
+
+/**
+ *  Like the other Typeface make methods, this returns a new reference to the
+ *  corresponding typeface for the specified CTFontRef.
+ */
+SK_API extern sk_sp<SkTypeface> SkMakeTypefaceFromCTFont(CTFontRef);
+
+/**
+ *  Returns the platform-specific CTFontRef handle for a
+ *  given SkTypeface. Note that the returned CTFontRef gets
+ *  released when the source SkTypeface is destroyed.
+ *
+ *  This method is deprecated. It may only be used by Blink Mac
+ *  legacy code in special cases related to text-shaping
+ *  with AAT fonts, clipboard handling and font fallback.
+ *  See https://code.google.com/p/skia/issues/detail?id=3408
+ */
+SK_API extern CTFontRef SkTypeface_GetCTFontRef(const SkTypeface* face);
+
+#endif  // defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
+#endif  // SkTypeface_mac_DEFINED

package/shared/skia/include/ports/SkTypeface_win.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkTypeface_win_DEFINED
+#define SkTypeface_win_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypeface.h"
+#include "include/core/SkTypes.h"
+
+#ifdef SK_BUILD_FOR_WIN
+
+#ifdef UNICODE
+typedef struct tagLOGFONTW LOGFONTW;
+typedef LOGFONTW LOGFONT;
+#else
+typedef struct tagLOGFONTA LOGFONTA;
+typedef LOGFONTA LOGFONT;
+#endif  // UNICODE
+
+/**
+ *  Like the other Typeface create methods, this returns a new reference to the
+ *  corresponding typeface for the specified logfont. The caller is responsible
+ *  for calling unref() when it is finished.
+ */
+SK_API sk_sp<SkTypeface> SkCreateTypefaceFromLOGFONT(const LOGFONT&);
+
+/**
+ *  Copy the LOGFONT associated with this typeface into the lf parameter. Note
+ *  that the lfHeight will need to be set afterwards, since the typeface does
+ *  not track this (the paint does).
+ *  typeface may be NULL, in which case we return the logfont for the default font.
+ */
+SK_API void SkLOGFONTFromTypeface(const SkTypeface* typeface, LOGFONT* lf);
+
+/**
+  *  Set an optional callback to ensure that the data behind a LOGFONT is loaded.
+  *  This will get called if Skia tries to access the data but hits a failure.
+  *  Normally this is null, and is only required if the font data needs to be
+  *  remotely (re)loaded.
+  */
+SK_API void SkTypeface_SetEnsureLOGFONTAccessibleProc(void (*)(const LOGFONT&));
+
+// Experimental!
+//
+class SkFontMgr;
+struct IDWriteFactory;
+struct IDWriteFontCollection;
+struct IDWriteFontFallback;
+
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_GDI();
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_DirectWrite(IDWriteFactory* factory = nullptr,
+                                                  IDWriteFontCollection* collection = nullptr);
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_DirectWrite(IDWriteFactory* factory,
+                                                  IDWriteFontCollection* collection,
+                                                  IDWriteFontFallback* fallback);
+
+#endif  // SK_BUILD_FOR_WIN
+#endif  // SkTypeface_win_DEFINED

package/shared/skia/include/private/SingleOwner.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_SingleOwner_DEFINED
+#define skgpu_SingleOwner_DEFINED
+
+#include "include/private/SkDebug.h" // IWYU pragma: keep
+
+#if defined(SK_DEBUG)
+#include "include/private/SkAssert.h"
+#include "include/private/SkMutex.h"
+#include "include/private/SkThreadAnnotations.h"
+#include "include/private/SkThreadID.h"
+
+#endif
+
+namespace skgpu {
+
+#if defined(SK_DEBUG)
+
+#define SKGPU_ASSERT_SINGLE_OWNER(obj) \
+    skgpu::SingleOwner::AutoEnforce debug_SingleOwner(obj, __FILE__, __LINE__);
+
+// This is a debug tool to verify an object is only being used from one thread at a time.
+class SingleOwner {
+public:
+     SingleOwner() : fOwner(kIllegalThreadID), fReentranceCount(0) {}
+
+     struct AutoEnforce {
+         AutoEnforce(SingleOwner* so, const char* file, int line)
+                : fFile(file), fLine(line), fSO(so) {
+             fSO->enter(file, line);
+         }
+         ~AutoEnforce() { fSO->exit(fFile, fLine); }
+
+         const char* fFile;
+         int fLine;
+         SingleOwner* fSO;
+     };
+
+private:
+     void enter(const char* file, int line) {
+         SkAutoMutexExclusive lock(fMutex);
+         SkThreadID self = SkGetThreadID();
+         SkASSERTF(fOwner == self || fOwner == kIllegalThreadID, "%s:%d Single owner failure.",
+                   file, line);
+         fReentranceCount++;
+         fOwner = self;
+     }
+
+     void exit(const char* file, int line) {
+         SkAutoMutexExclusive lock(fMutex);
+         SkASSERTF(fOwner == SkGetThreadID(), "%s:%d Single owner failure.", file, line);
+         fReentranceCount--;
+         if (fReentranceCount == 0) {
+             fOwner = kIllegalThreadID;
+         }
+     }
+
+     SkMutex fMutex;
+     SkThreadID fOwner    SK_GUARDED_BY(fMutex);
+     int fReentranceCount SK_GUARDED_BY(fMutex);
+};
+#else
+#define SKGPU_ASSERT_SINGLE_OWNER(obj)
+class SingleOwner {}; // Provide a no-op implementation so we can pass pointers to constructors
+#endif
+
+} // namespace skgpu
+
+#endif

package/shared/skia/include/private/SkAPI.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkAPI_DEFINED
+#define SkAPI_DEFINED
+
+#include "include/private/SkLoadUserConfig.h" // IWYU pragma: keep
+
+// If SKIA_IMPLEMENTATION is defined as 1, that signals we are building Skia and should
+// export our symbols. If it is not set (or set to 0), then Skia is being used by a client
+// and we should not export our symbols.
+#if !defined(SKIA_IMPLEMENTATION)
+    #define SKIA_IMPLEMENTATION 0
+#endif
+
+// If we are compiling Skia is being as a DLL, we need to be sure to export all of our public
+// APIs to that DLL. If a client is using Skia which was compiled as a DLL, we need to instruct
+// the linker to use the symbols from that DLL. This is the goal of the SK_API define.
+#if !defined(SK_API)
+    #if defined(SKIA_DLL)
+        #if defined(_MSC_VER)
+            #if SKIA_IMPLEMENTATION
+                #define SK_API __declspec(dllexport)
+            #else
+                #define SK_API __declspec(dllimport)
+            #endif
+        #else
+            #define SK_API __attribute__((visibility("default")))
+        #endif
+    #else
+        #define SK_API
+    #endif
+#endif
+
+// SK_SPI is functionally identical to SK_API, but used within src to clarify that it's less stable
+#if !defined(SK_SPI)
+    #define SK_SPI SK_API
+#endif
+
+// See https://clang.llvm.org/docs/AttributeReference.html#availability
+// The API_AVAILABLE macro comes from <os/availability.h> on MacOS
+#if defined(SK_ENABLE_API_AVAILABLE)
+#   define SK_API_AVAILABLE API_AVAILABLE
+#else
+#   define SK_API_AVAILABLE(...)
+#endif
+
+#endif