expo-gl 56.0.2 → 56.0.4

package/CHANGELOG.md

@@ -10,6 +10,14 @@
 
 ### 💡 Others
 
+## 56.0.4 — 2026-05-15
+
+_This version does not introduce any user-facing changes._
+
+## 56.0.3 — 2026-05-06
+
+_This version does not introduce any user-facing changes._
+
 ## 56.0.2 — 2026-05-06
 
 _This version does not introduce any user-facing changes._

package/android/CMakeLists.txt

@@ -21,6 +21,8 @@ add_library(
     ${COMMON_DIR}/EXGLContextManager.cpp
     ${COMMON_DIR}/EXGLContextManager.h
     ${COMMON_DIR}/EXWebGLMethods.cpp
+    ${COMMON_DIR}/EXWebGLMethodsTextures.cpp
+    ${COMMON_DIR}/EXWebGLMethodsDraw.cpp
     ${COMMON_DIR}/EXWebGLMethods.h
     ${COMMON_DIR}/EXWebGLRenderer.cpp
     ${COMMON_DIR}/EXWebGLRenderer.h
@@ -46,4 +48,5 @@ target_compile_options(
             -Wno-unused-parameter
             -Wshorten-64-to-32
             -Wstrict-prototypes)
+target_precompile_headers(${PACKAGE_NAME} PRIVATE ${COMMON_DIR}/pch.h)
 target_link_libraries(${PACKAGE_NAME} ReactAndroid::jsi ${LOG_LIB} ${GLES_LIB} android)

package/android/build.gradle

@@ -1,3 +1,5 @@
+import groovy.json.JsonSlurper
+
 plugins {
   id 'com.android.library'
   id 'expo-module-gradle-plugin'
@@ -9,7 +11,7 @@ def reactNativeArchitectures() {
 }
 
 group = 'host.exp.exponent'
-version = '56.0.2'
+version = '56.0.4'
 
 android {
   if (rootProject.hasProperty("ndkPath")) {
@@ -22,7 +24,7 @@ android {
   namespace "expo.modules.gl"
   defaultConfig {
     versionCode 31
-    versionName "56.0.2"
+    versionName "56.0.4"
 
     externalNativeBuild {
       cmake {
@@ -61,3 +63,57 @@ dependencies {
   compileOnly 'com.facebook.soloader:soloader:0.8.2'
   compileOnly 'com.facebook.react:react-android'
 }
+
+// Generates minimal stub PCH files from an empty header so the IDE's C++ engine
+// doesn't fail during sync. Near-instant unlike the full ExpoHeader.pch.
+// The actual build regenerates proper PCH files via ninja.
+def cxxDir = project.file(".cxx")
+def generateStubPCHTask = tasks.register("generateStubPCH") {
+  dependsOn("configureCMakeDebug")
+
+  doLast {
+    if (!cxxDir.exists()) {
+      return
+    }
+
+    cxxDir.eachFileRecurse { file ->
+      if (file.name != "compile_commands.json") {
+        return
+      }
+
+      new JsonSlurper().parseText(file.text).each { entry ->
+        if (!entry.file.endsWith("cmake_pch.hxx.cxx")) {
+          return
+        }
+
+        def pchFile = new File(entry.file.substring(0, entry.file.length() - ".cxx".length()) + ".pch")
+
+        if (!pchFile.exists() || pchFile.length() == 0) {
+          def stubHeader = new File(entry.directory, "stub_pch.hxx")
+          stubHeader.text = ""
+
+          def cmd = entry.command
+            // Replace the forced-include path: `-Xclang -include -Xclang <path>/cmake_pch.hxx`
+            .replaceAll(/-Xclang -include -Xclang [^\s]+cmake_pch\.hxx(?=\s)/, "-Xclang -include -Xclang ${stubHeader.absolutePath}")
+            // Replace the source file operand: `<path>/cmake_pch.hxx.cxx`
+            .replaceAll(/[^\s]+cmake_pch\.hxx\.cxx/, stubHeader.absolutePath)
+
+          def process = new ProcessBuilder(cmd.split(" ").toList())
+            .directory(new File(entry.directory))
+            .redirectErrorStream(true)
+            .start()
+          if (process.waitFor() != 0) {
+            throw new GradleException("Stub PCH generation failed: ${process.inputStream.text}")
+          }
+        }
+
+        // Ensure PCH is older than source so ninja rebuilds the real one during build
+        pchFile.setLastModified(new File(entry.file).lastModified() - 1)
+      }
+    }
+  }
+}
+
+tasks.register("prepareKotlinBuildScriptModel") {
+  dependsOn(generateStubPCHTask)
+}

package/android/src/main/cpp/EXGLJniApi.cpp

@@ -1,10 +1,6 @@
-#include <stdint.h>
-
 #include <jni.h>
 #include <thread>
-#include <android/log.h>
 
-#include <jsi/jsi.h>
 #include "EXGLNativeApi.h"
 #include "EXPlatformUtils.h"
 
@@ -12,7 +8,7 @@ extern "C" {
 
 // JNIEnv is valid only inside the same thread that it was passed from
 // to support worklet we need register it from UI thread
-thread_local JNIEnv* threadLocalEnv;
+thread_local JNIEnv *threadLocalEnv;
 
 JNIEXPORT jint JNICALL
 Java_expo_modules_gl_cpp_EXGL_EXGLContextCreate
@@ -31,7 +27,7 @@ Java_expo_modules_gl_cpp_EXGL_EXGLContextPrepare
   std::function<void(void)> flushMethod = [glContextRef, flushMethodRef] {
     threadLocalEnv->CallVoidMethod(glContextRef, flushMethodRef);
   };
-  EXGLContextPrepare((void*) jsiPtr, exglCtxId, flushMethod);
+  EXGLContextPrepare((void *) jsiPtr, exglCtxId, flushMethod);
 }
 
 JNIEXPORT void JNICALL
@@ -77,7 +73,7 @@ Java_expo_modules_gl_cpp_EXGL_EXGLContextGetObject
   return EXGLContextGetObject(exglCtxId, exglObjId);
 }
 
-JNIEXPORT bool JNICALL
+JNIEXPORT jboolean JNICALL
 Java_expo_modules_gl_cpp_EXGL_EXGLContextNeedsRedraw
 (JNIEnv *env, jclass clazz, jint exglCtxId) {
   return EXGLContextNeedsRedraw(exglCtxId);

package/common/EXGLContextManager.cpp

@@ -1,5 +1,7 @@
 #include "EXGLContextManager.h"
-#include <mutex>
+#include "EXGLNativeContext.h"
+#include <chrono>
+#include <thread>
 
 namespace expo {
 namespace gl_cpp {

package/common/EXGLContextManager.h

@@ -1,15 +1,22 @@
 #pragma once
 
+#include "pch.h"
+
 #include <shared_mutex>
-#include "EXGLNativeContext.h"
+
+#include "EXGLNativeApi.h"
 
 namespace expo {
 namespace gl_cpp {
 
+class EXGLContext;
+
 using ContextWithLock = std::pair<EXGLContext *, std::shared_lock<std::shared_mutex>>;
 
 EXGLContextId ContextCreate();
+
 ContextWithLock ContextGet(EXGLContextId id);
+
 void ContextDestroy(EXGLContextId id);
 
 } // namespace gl_cpp

package/common/EXGLImageUtils.cpp

@@ -3,6 +3,7 @@
 #define STBI_ONLY_JPEG
 #define STBI_ONLY_PNG
 #define STB_IMAGE_IMPLEMENTATION
+
 #include "stb_image.h"
 
 namespace jsi = facebook::jsi;
@@ -47,14 +48,14 @@ void flipPixels(GLubyte *pixels, size_t bytesPerRow, size_t rows) {
     return;
   }
 
-  GLuint middle = (GLuint)rows / 2;
-  GLuint intsPerRow = (GLuint)bytesPerRow / sizeof(GLuint);
-  GLuint remainingBytes = (GLuint)bytesPerRow - intsPerRow * sizeof(GLuint);
+  GLuint middle = (GLuint) rows / 2;
+  GLuint intsPerRow = (GLuint) bytesPerRow / sizeof(GLuint);
+  GLuint remainingBytes = (GLuint) bytesPerRow - intsPerRow * sizeof(GLuint);
 
-  for (GLuint rowTop = 0, rowBottom = (GLuint)rows - 1; rowTop < middle; ++rowTop, --rowBottom) {
+  for (GLuint rowTop = 0, rowBottom = (GLuint) rows - 1; rowTop < middle; ++rowTop, --rowBottom) {
     // Swap in packs of sizeof(GLuint) bytes
-    GLuint *iTop = (GLuint *)(pixels + rowTop * bytesPerRow);
-    GLuint *iBottom = (GLuint *)(pixels + rowBottom * bytesPerRow);
+    GLuint *iTop = (GLuint *) (pixels + rowTop * bytesPerRow);
+    GLuint *iBottom = (GLuint *) (pixels + rowBottom * bytesPerRow);
     GLuint iTmp;
     GLuint n = intsPerRow;
     do {
@@ -64,8 +65,8 @@ void flipPixels(GLubyte *pixels, size_t bytesPerRow, size_t rows) {
     } while (--n > 0);
 
     // Swap remainder bytes
-    GLubyte *bTop = (GLubyte *)iTop;
-    GLubyte *bBottom = (GLubyte *)iBottom;
+    GLubyte *bTop = (GLubyte *) iTop;
+    GLubyte *bBottom = (GLubyte *) iBottom;
     GLubyte bTmp;
     switch (remainingBytes) {
       case 3:
@@ -117,11 +118,11 @@ void decodeURI(char *dst, const char *src) {
 }
 
 std::shared_ptr<uint8_t> loadImage(
-    jsi::Runtime &runtime,
-    const jsi::Object &jsPixels,
-    int *fileWidth,
-    int *fileHeight,
-    int *fileComp) {
+  jsi::Runtime &runtime,
+  const jsi::Object &jsPixels,
+  int *fileWidth,
+  int *fileHeight,
+  int *fileComp) {
   auto localUriProp = jsPixels.getProperty(runtime, "localUri");
   if (localUriProp.isString()) {
     auto localUri = localUriProp.asString(runtime).utf8(runtime);
@@ -132,8 +133,8 @@ std::shared_ptr<uint8_t> loadImage(
     decodeURI(localPath, localUri.c_str() + 7);
 
     return std::shared_ptr<uint8_t>(
-        stbi_load(localPath, fileWidth, fileHeight, fileComp, STBI_rgb_alpha),
-        [](void *data) { stbi_image_free(data); });
+      stbi_load(localPath, fileWidth, fileHeight, fileComp, STBI_rgb_alpha),
+      [](void *data) { stbi_image_free(data); });
   }
   return std::shared_ptr<uint8_t>(nullptr);
 }

package/common/EXGLImageUtils.h

@@ -1,15 +1,6 @@
 #pragma once
 
-#ifdef __ANDROID__
-#include <GLES3/gl3.h>
-#include <GLES3/gl3ext.h>
-#endif
-#ifdef __APPLE__
-#include <OpenGLES/ES3/gl.h>
-#endif
-
-#include <jsi/jsi.h>
-#include <vector>
+#include "pch.h"
 
 namespace expo {
 namespace gl_cpp {
@@ -19,10 +10,10 @@ GLuint bytesPerPixel(GLenum type, GLenum format);
 void flipPixels(GLubyte *pixels, size_t bytesPerRow, size_t rows);
 
 std::shared_ptr<uint8_t> loadImage(
-    facebook::jsi::Runtime &runtime,
-    const facebook::jsi::Object &jsPixels,
-    int *fileWidth,
-    int *fileHeight,
-    int *fileComp);
+  facebook::jsi::Runtime &runtime,
+  const facebook::jsi::Object &jsPixels,
+  int *fileWidth,
+  int *fileHeight,
+  int *fileComp);
 } // namespace gl_cpp
 } // namespace expo

package/common/EXGLNativeApi.cpp

@@ -9,9 +9,9 @@ EXGLContextId EXGLContextCreate() {
 }
 
 void EXGLContextPrepare(
-    void *jsiPtr,
-    EXGLContextId exglCtxId,
-    std::function<void(void)> flushMethod) {
+  void *jsiPtr,
+  EXGLContextId exglCtxId,
+  std::function<void(void)> flushMethod) {
   auto [exglCtx, lock] = ContextGet(exglCtxId);
   if (exglCtx) {
     exglCtx->prepareContext(*reinterpret_cast<jsi::Runtime *>(jsiPtr), flushMethod);

package/common/EXGLNativeContext.cpp

@@ -1,4 +1,7 @@
 #include "EXGLNativeContext.h"
+
+#include <future>
+
 #include "EXPlatformUtils.h"
 
 namespace expo {
@@ -34,7 +37,7 @@ void EXGLContext::maybeResolveWorkletContext(jsi::Runtime &runtime) {
     return;
   }
   uintptr_t rawWorkletRuntimePointer =
-      *reinterpret_cast<uintptr_t *>(workletRuntimeArrayBuffer.data(runtime));
+    *reinterpret_cast<uintptr_t *>(workletRuntimeArrayBuffer.data(runtime));
   jsi::Runtime *workletRuntime = reinterpret_cast<jsi::Runtime *>(rawWorkletRuntimePointer);
   this->maybeWorkletRuntime = workletRuntime;
 }
@@ -45,7 +48,7 @@ void EXGLContext::prepareWorkletContext() {
   }
   jsi::Runtime &runtime = *this->maybeWorkletRuntime;
   createWebGLRenderer(
-      runtime, this, initialGlesContext, runtime.global().getPropertyAsObject(runtime, "global"));
+    runtime, this, initialGlesContext, runtime.global().getPropertyAsObject(runtime, "global"));
   tryRegisterOnJSRuntimeDestroy(runtime);
 }
 
@@ -76,8 +79,8 @@ void EXGLContext::addBlockingToNextBatch(Op &&op) {
 // [JS thread] Enqueue a function and return an EXGL object that will get mapped
 // to the function's return value when it is called on the GL thread.
 jsi::Value EXGLContext::addFutureToNextBatch(
-    jsi::Runtime &runtime,
-    std::function<unsigned int(void)> &&op) noexcept {
+  jsi::Runtime &runtime,
+  std::function<unsigned int(void)> &&op) noexcept {
   auto exglObjId = createObject();
   addToNextBatch([=] {
     assert(objects.find(exglObjId) == objects.end());
@@ -94,8 +97,8 @@ void EXGLContext::flush(void) {
     std::lock_guard<std::mutex> lock(backlogMutex);
     std::swap(backlog, copy);
   }
-  for (const auto &batch : copy) {
-    for (const auto &op : batch) {
+  for (const auto &batch: copy) {
+    for (const auto &op: batch) {
       op();
     }
   }
@@ -128,10 +131,10 @@ void EXGLContext::tryRegisterOnJSRuntimeDestroy(jsi::Runtime &runtime) {
   // `jsi::Runtime` is being destroyed and that will trigger destructor of
   // `InvalidateCacheOnDestroy` class which will invalidate JSI PropNameID cache.
   global.setProperty(
-      runtime,
-      OnJSRuntimeDestroyPropertyName,
-      jsi::Object::createFromHostObject(
-          runtime, std::make_shared<InvalidateCacheOnDestroy>(runtime)));
+    runtime,
+    OnJSRuntimeDestroyPropertyName,
+    jsi::Object::createFromHostObject(
+      runtime, std::make_shared<InvalidateCacheOnDestroy>(runtime)));
 }
 
 glesContext EXGLContext::prepareOpenGLESContext() {

package/common/EXGLNativeContext.h

@@ -1,28 +1,11 @@
 #pragma once
 
-#include "EXGLNativeApi.h"
-
-#ifdef __ANDROID__
-#include <GLES3/gl3.h>
-#include <GLES3/gl3ext.h>
-#endif
-#ifdef __APPLE__
-#include <OpenGLES/EAGL.h>
-#include <OpenGLES/ES3/gl.h>
-#include <OpenGLES/ES3/glext.h>
-#endif
+#include "pch.h"
 
-#include "EXTypedArrayApi.h"
-
-#include <exception>
-#include <future>
 #include <set>
-#include <sstream>
-#include <unordered_map>
-#include <vector>
-
-#include <jsi/jsi.h>
 
+#include "EXGLNativeApi.h"
+#include "EXTypedArrayApi.h"
 #include "EXJsiUtils.h"
 #include "EXPlatformUtils.h"
 #include "EXWebGLRenderer.h"
@@ -48,10 +31,13 @@ class EXGLContext {
   using Op = std::function<void(void)>;
   using Batch = std::vector<Op>;
 
- public:
+public:
   EXGLContext(EXGLContextId ctxId) : ctxId(ctxId) {}
+
   void prepareContext(jsi::Runtime &runtime, std::function<void(void)> flushMethod);
+
   void maybeResolveWorkletContext(jsi::Runtime &runtime);
+
   void prepareWorkletContext();
 
   // --- Queue handling --------------------------------------------------------
@@ -67,8 +53,10 @@ class EXGLContext {
 
   // [JS thread] Send the current 'next' batch to GL and make a new 'next' batch
   void endNextBatch() noexcept;
+
   // [JS thread] Add an Op to the 'next' batch
   void addToNextBatch(Op &&op) noexcept;
+
   // [JS thread] Add a blocking operation to the 'next' batch -- waits for the
   // queued function to run before returning
   void addBlockingToNextBatch(Op &&op);
@@ -86,8 +74,9 @@ class EXGLContext {
   // To make it work lookupObject can be called only on GL thread
   //
   jsi::Value addFutureToNextBatch(
-      jsi::Runtime &runtime,
-      std::function<unsigned int(void)> &&op) noexcept;
+    jsi::Runtime &runtime,
+    std::function<unsigned int(void)> &&op
+  ) noexcept;
 
   // [GL thread] Do all the remaining work we can do on the GL thread
   // triggered by call to flushOnGLThread
@@ -102,21 +91,26 @@ class EXGLContext {
   // mutex on the mapping.
 
   EXGLObjectId createObject(void) noexcept;
+
   void destroyObject(EXGLObjectId exglObjId) noexcept;
+
   void mapObject(EXGLObjectId exglObjId, GLuint glObj) noexcept;
+
   GLuint lookupObject(EXGLObjectId exglObjId) noexcept;
 
   void tryRegisterOnJSRuntimeDestroy(jsi::Runtime &runtime);
+
   glesContext prepareOpenGLESContext();
+
   void maybeReadAndCacheSupportedExtensions();
 
- private:
+private:
   // Queue
   Batch nextBatch;
   std::vector<Batch> backlog;
   std::mutex backlogMutex;
 
- public:
+public:
   EXGLContextId ctxId;
   // Worklet runtime is stored here only to avoid it passing through Java/Obj-C.
   // It should only be used in prepareContext and prepareWorkletContext.