Merge pull request #1261 from dsnopek/4.1-cherrypicks-4

Cherry-picks for the godot-cpp 4.1 branch - 4th batch

Author: akien-mga

.github/workflows/ci.yml

@@ -78,8 +78,18 @@ jobs:
  run-tests: false
  cache-name: ios-arm64
 
+ - name: 🌐 Web (wasm32)
+ os: ubuntu-20.04
+ platform: javascript
+ artifact-name: godot-cpp-javascript-wasm32-release
+ artifact-path: bin/libgodot-cpp.javascript.template_release.wasm32.a
+ run-tests: false
+ cache-name: javascript-wasm32
+
  env:
  SCONS_CACHE: ${{ github.workspace }}/.scons-cache/
+ EM_VERSION: 3.1.45
+ EM_CACHE_FOLDER: "emsdk-cache"
 
  steps:
  - name: Checkout
@@ -104,6 +114,13 @@ jobs:
  sudo apt-get update -qq
  sudo apt-get install -qqq build-essential pkg-config
 
+ - name: Web dependencies
+ if: ${{ matrix.platform == 'javascript' }}
+ uses: mymindstorm/setup-emsdk@v12
+ with:
+ version: ${{env.EM_VERSION}}
+ actions-cache-folder: ${{env.EM_CACHE_FOLDER}}
+
  - name: Install scons
  run: |
  python -m pip install scons==4.0.0

SConstruct

@@ -21,6 +21,10 @@ env.PrependENVPath("PATH", os.getenv("PATH"))
 
 # Custom options and profile flags.
 customs = ["custom.py"]
+try:
+ customs += Import("customs")
+except:
+ pass
 profile = ARGUMENTS.get("profile", "")
 if profile:
  if os.path.isfile(profile):

binding_generator.py

@@ -1519,13 +1519,13 @@ def generate_engine_class_source(class_api, used_classes, fully_used_classes, us
  f"\t\tGDExtensionObjectPtr singleton_obj = internal::gdextension_interface_global_get_singleton({class_name}::get_class_static()._native_ptr());"
  )
  result.append("#ifdef DEBUG_ENABLED")
- result.append("\t\tERR_FAIL_COND_V(singleton_obj == nullptr, nullptr);")
+ result.append("\t\tERR_FAIL_NULL_V(singleton_obj, nullptr);")
  result.append("#endif // DEBUG_ENABLED")
  result.append(
  f"\t\tsingleton = reinterpret_cast<{class_name} *>(internal::gdextension_interface_object_get_instance_binding(singleton_obj, internal::token, &{class_name}::_gde_binding_callbacks));"
  )
  result.append("#ifdef DEBUG_ENABLED")
- result.append("\t\tERR_FAIL_COND_V(singleton == nullptr, nullptr);")
+ result.append("\t\tERR_FAIL_NULL_V(singleton, nullptr);")
  result.append("#endif // DEBUG_ENABLED")
  result.append("\t}")
  result.append("\treturn singleton;")

include/godot_cpp/classes/ref.hpp

@@ -63,7 +63,7 @@ class Ref {
 }
 
 void ref_pointer(T *p_ref) {
-ERR_FAIL_COND(!p_ref);
+ERR_FAIL_NULL(p_ref);
 
 if (p_ref->init_ref()) {
 reference = p_ref;

include/godot_cpp/core/class_db.hpp

@@ -257,7 +257,7 @@ MethodBind *ClassDB::bind_static_method(StringName p_class, N p_method_name, M p
 template <class M>
 MethodBind *ClassDB::bind_vararg_method(uint32_t p_flags, StringName p_name, M p_method, const MethodInfo &p_info, const std::vector<Variant> &p_default_args, bool p_return_nil_is_variant) {
 MethodBind *bind = create_vararg_method_bind(p_method, p_info, p_return_nil_is_variant);
-ERR_FAIL_COND_V(!bind, nullptr);
+ERR_FAIL_NULL_V(bind, nullptr);
 
 bind->set_name(p_name);
 bind->set_default_arguments(p_default_args);

include/godot_cpp/core/memory.hpp

@@ -146,7 +146,7 @@ T *memnew_arr_template(size_t p_elements, const char *p_descr = "") {
 size_t len = sizeof(T) * p_elements;
 uint64_t *mem = (uint64_t *)Memory::alloc_static(len, true);
 T *failptr = nullptr; // Get rid of a warning.
-ERR_FAIL_COND_V(!mem, failptr);
+ERR_FAIL_NULL_V(mem, failptr);
 *(mem - 1) = p_elements;
 
 if (!std::is_trivially_destructible<T>::value) {

include/godot_cpp/templates/cowdata.hpp

@@ -102,6 +102,10 @@ class CowData {
 }
 
 _FORCE_INLINE_ bool _get_alloc_size_checked(size_t p_elements, size_t *out) const {
+if (unlikely(p_elements == 0)) {
+*out = 0;
+return true;
+}
 #if defined(__GNUC__)
 size_t o;
 size_t p;
@@ -113,13 +117,12 @@ class CowData {
 if (__builtin_add_overflow(o, static_cast<size_t>(32), &p)) {
 return false; // No longer allocated here.
 }
-return true;
 #else
 // Speed is more important than correctness here, do the operations unchecked
 // and hope for the best.
 *out = _get_alloc_size(p_elements);
-return true;
 #endif
+return *out;
 }
 
 void _unref(void *p_data);
@@ -294,15 +297,15 @@ Error CowData<T>::resize(int p_size) {
 if (current_size == 0) {
 // alloc from scratch
 uint32_t *ptr = (uint32_t *)Memory::alloc_static(alloc_size, true);
-ERR_FAIL_COND_V(!ptr, ERR_OUT_OF_MEMORY);
+ERR_FAIL_NULL_V(ptr, ERR_OUT_OF_MEMORY);
 *(ptr - 1) = 0; // size, currently none
 new (ptr - 2) SafeNumeric<uint32_t>(1); // refcount
 
 _ptr = (T *)ptr;
 
 } else {
 uint32_t *_ptrnew = (uint32_t *)Memory::realloc_static(_ptr, alloc_size, true);
-ERR_FAIL_COND_V(!_ptrnew, ERR_OUT_OF_MEMORY);
+ERR_FAIL_NULL_V(_ptrnew, ERR_OUT_OF_MEMORY);
 new (_ptrnew - 2) SafeNumeric<uint32_t>(rc); // refcount
 
 _ptr = (T *)(_ptrnew);
@@ -332,7 +335,7 @@ Error CowData<T>::resize(int p_size) {
 
 if (alloc_size != current_alloc_size) {
 uint32_t *_ptrnew = (uint32_t *)Memory::realloc_static(_ptr, alloc_size, true);
-ERR_FAIL_COND_V(!_ptrnew, ERR_OUT_OF_MEMORY);
+ERR_FAIL_NULL_V(_ptrnew, ERR_OUT_OF_MEMORY);
 new (_ptrnew - 2) SafeNumeric<uint32_t>(rc); // refcount
 
 _ptr = (T *)(_ptrnew);

include/godot_cpp/templates/list.hpp

@@ -221,7 +221,7 @@ class List {
 int size_cache = 0;
 
 bool erase(const Element *p_I) {
-ERR_FAIL_COND_V(!p_I, false);
+ERR_FAIL_NULL_V(p_I, false);
 ERR_FAIL_COND_V(p_I->data != this, false);
 
 if (first == p_I) {

include/godot_cpp/templates/rid_owner.hpp

@@ -186,12 +186,12 @@ class RID_Alloc {
 }
 void initialize_rid(RID p_rid) {
 T *mem = get_or_null(p_rid, true);
-ERR_FAIL_COND(!mem);
+ERR_FAIL_NULL(mem);
 memnew_placement(mem, T);
 }
 void initialize_rid(RID p_rid, const T &p_value) {
 T *mem = get_or_null(p_rid, true);
-ERR_FAIL_COND(!mem);
+ERR_FAIL_NULL(mem);
 memnew_placement(mem, T(p_value));
 }
 
@@ -374,7 +374,7 @@ class RID_PtrOwner {
 
 _FORCE_INLINE_ void replace(const RID &p_rid, T *p_new_ptr) {
 T **ptr = alloc.get_or_null(p_rid);
-ERR_FAIL_COND(!ptr);
+ERR_FAIL_NULL(ptr);
 *ptr = p_new_ptr;
 }
 

include/godot_cpp/templates/thread_work_pool.hpp

@@ -96,7 +96,7 @@ class ThreadWorkPool {
 public:
 template <class C, class M, class U>
 void begin_work(uint32_t p_elements, C *p_instance, M p_method, U p_userdata) {
-ERR_FAIL_COND(!threads); // never initialized
+ERR_FAIL_NULL(threads); // Never initialized.
 ERR_FAIL_COND(current_work != nullptr);
 
 index.store(0, std::memory_order_release);
@@ -123,18 +123,18 @@ class ThreadWorkPool {
 }
 
 bool is_done_dispatching() const {
-ERR_FAIL_COND_V(current_work == nullptr, true);
+ERR_FAIL_NULL_V(current_work, true);
 return index.load(std::memory_order_acquire) >= current_work->max_elements;
 }
 
 uint32_t get_work_index() const {
-ERR_FAIL_COND_V(current_work == nullptr, 0);
+ERR_FAIL_NULL_V(current_work, 0);
 uint32_t idx = index.load(std::memory_order_acquire);
 return Math::min(idx, current_work->max_elements);
 }
 
 void end_work() {
-ERR_FAIL_COND(current_work == nullptr);
+ERR_FAIL_NULL(current_work);
 for (uint32_t i = 0; i < threads_working; i++) {
 threads[i].completed.wait();
 threads[i].work = nullptr;