@babylonjs/react-native 2.0.0 → 2.0.1-preview

package/shared/BabylonNative/deps/spirv-cross-src/spirv_hlsl.cpp

@@ -4606,7 +4606,6 @@ void CompilerHLSL::emit_instruction(const Instruction &instruction)
 	}
 	case OpBitcast:
 	{
-#ifndef SPIRV_CROSS_WEBMIN
 		auto bitcast_type = get_bitcast_type(ops[0], ops[2]);
 		if (bitcast_type == CompilerHLSL::TypeNormal)
 			CompilerGLSL_emit_instruction(instruction);
@@ -4623,9 +4622,6 @@ void CompilerHLSL::emit_instruction(const Instruction &instruction)
 			else
 				emit_unary_func_op(ops[0], ops[1], ops[2], "spvUnpackUint2x32");
 		}
-#else
-		SPIRV_CROSS_INVALID_CALL();
-#endif
 		break;
 	}
 
@@ -4748,7 +4744,6 @@ void CompilerHLSL::emit_instruction(const Instruction &instruction)
 
 	case OpImage:
 	{
-#ifndef SPIRV_CROSS_WEBMIN
 		uint32_t result_type = ops[0];
 		uint32_t id = ops[1];
 		auto *combined = maybe_get<SPIRCombinedImageSampler>(ops[2]);
@@ -4767,9 +4762,6 @@ void CompilerHLSL::emit_instruction(const Instruction &instruction)
 			if (var)
 				e.loaded_from = var->self;
 		}
-#else
-		SPIRV_CROSS_INVALID_CALL();
-#endif
 		break;
 	}
 
@@ -5083,7 +5075,6 @@ void CompilerHLSL::emit_instruction(const Instruction &instruction)
 
 	case OpImageQuerySizeLod:
 	{
-#ifndef SPIRV_CROSS_WEBMIN
 		auto result_type = ops[0];
 		auto id = ops[1];
 
@@ -5097,9 +5088,6 @@ void CompilerHLSL::emit_instruction(const Instruction &instruction)
 		auto &restype = get<SPIRType>(ops[0]);
 		expr = bitcast_expression(restype, SPIRType::UInt, expr);
 		emit_op(result_type, id, expr, true);
-#else
-		SPIRV_CROSS_INVALID_CALL();
-#endif
 		break;
 	}
 
@@ -13057,12 +13045,8 @@ void CompilerHLSL::CompilerGLSL_emit_instruction(const Instruction &instruction)
 
 	case OpISub:
 	{
-#ifndef SPIRV_CROSS_WEBMIN
 		auto type = get<SPIRType>(ops[0]).basetype;
 		GLSL_BOP_CAST(-, type);
-#else
-		SPIRV_CROSS_INVALID_CALL();
-#endif
 		break;
 	}
 
@@ -13700,7 +13684,6 @@ void CompilerHLSL::CompilerGLSL_emit_instruction(const Instruction &instruction)
 
 	case OpBitcast:
 	{
-#ifndef SPIRV_CROSS_WEBMIN
 		uint32_t result_type = ops[0];
 		uint32_t id = ops[1];
 		uint32_t arg = ops[2];
@@ -13710,9 +13693,6 @@ void CompilerHLSL::CompilerGLSL_emit_instruction(const Instruction &instruction)
 			auto op = bitcast_glsl_op(get<SPIRType>(result_type), expression_type(arg));
 			emit_unary_func_op(result_type, id, arg, op.c_str());
 		}
-#else
-		SPIRV_CROSS_INVALID_CALL();
-#endif
 		break;
 	}
 
@@ -16161,6 +16141,178 @@ bool CompilerHLSL::should_suppress_usage_tracking(uint32_t id) const
 	return !expression_is_forwarded(id) || expression_suppresses_usage_tracking(id);
 }
 
+
+CompilerHLSL::BitcastType CompilerHLSL::get_bitcast_type(uint32_t result_type, uint32_t op0)
+{
+	auto &rslt_type = get<SPIRType>(result_type);
+	auto &expr_type = expression_type(op0);
+
+	if (rslt_type.basetype == SPIRType::BaseType::UInt64 && expr_type.basetype == SPIRType::BaseType::UInt &&
+	    expr_type.vecsize == 2)
+		return BitcastType::TypePackUint2x32;
+	else if (rslt_type.basetype == SPIRType::BaseType::UInt && rslt_type.vecsize == 2 &&
+	         expr_type.basetype == SPIRType::BaseType::UInt64)
+		return BitcastType::TypeUnpackUint64;
+
+	return BitcastType::TypeNormal;
+}
+
+string CompilerHLSL::bitcast_glsl_op(const SPIRType &out_type, const SPIRType &in_type)
+{
+	if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::Int)
+		return type_to_glsl(out_type);
+	else if (out_type.basetype == SPIRType::UInt64 && in_type.basetype == SPIRType::Int64)
+		return type_to_glsl(out_type);
+	else if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::Float)
+		return "asuint";
+	else if (out_type.basetype == SPIRType::Int && in_type.basetype == SPIRType::UInt)
+		return type_to_glsl(out_type);
+	else if (out_type.basetype == SPIRType::Int64 && in_type.basetype == SPIRType::UInt64)
+		return type_to_glsl(out_type);
+	else if (out_type.basetype == SPIRType::Int && in_type.basetype == SPIRType::Float)
+		return "asint";
+	else if (out_type.basetype == SPIRType::Float && in_type.basetype == SPIRType::UInt)
+		return "asfloat";
+	else if (out_type.basetype == SPIRType::Float && in_type.basetype == SPIRType::Int)
+		return "asfloat";
+	else if (out_type.basetype == SPIRType::Int64 && in_type.basetype == SPIRType::Double)
+		SPIRV_CROSS_THROW("Double to Int64 is not supported in HLSL.");
+	else if (out_type.basetype == SPIRType::UInt64 && in_type.basetype == SPIRType::Double)
+		SPIRV_CROSS_THROW("Double to UInt64 is not supported in HLSL.");
+	else if (out_type.basetype == SPIRType::Double && in_type.basetype == SPIRType::Int64)
+		return "asdouble";
+	else if (out_type.basetype == SPIRType::Double && in_type.basetype == SPIRType::UInt64)
+		return "asdouble";
+	else if (out_type.basetype == SPIRType::Half && in_type.basetype == SPIRType::UInt && in_type.vecsize == 1)
+	{
+		if (!requires_explicit_fp16_packing)
+		{
+			requires_explicit_fp16_packing = true;
+			force_recompile();
+		}
+		return "spvUnpackFloat2x16";
+	}
+	else if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::Half && in_type.vecsize == 2)
+	{
+		if (!requires_explicit_fp16_packing)
+		{
+			requires_explicit_fp16_packing = true;
+			force_recompile();
+		}
+		return "spvPackFloat2x16";
+	}
+	else if (out_type.basetype == SPIRType::UShort && in_type.basetype == SPIRType::Half)
+	{
+		if (hlsl_options.shader_model < 40)
+			SPIRV_CROSS_THROW("Half to UShort requires Shader Model 4.");
+		return "(" + type_to_glsl(out_type) + ")f32tof16";
+	}
+	else if (out_type.basetype == SPIRType::Half && in_type.basetype == SPIRType::UShort)
+	{
+		if (hlsl_options.shader_model < 40)
+			SPIRV_CROSS_THROW("UShort to Half requires Shader Model 4.");
+		return "(" + type_to_glsl(out_type) + ")f16tof32";
+	}
+	else
+		return "";
+}
+
+void CompilerHLSL::require_texture_query_variant(uint32_t var_id)
+{
+	if (const auto *var = maybe_get_backing_variable(var_id))
+		var_id = var->self;
+
+	auto &type = expression_type(var_id);
+	bool uav = type.image.sampled == 2;
+	if (hlsl_options.nonwritable_uav_texture_as_srv && has_decoration(var_id, DecorationNonWritable))
+		uav = false;
+
+	uint32_t bit = 0;
+	switch (type.image.dim)
+	{
+	case Dim1D:
+		bit = type.image.arrayed ? Query1DArray : Query1D;
+		break;
+
+	case Dim2D:
+		if (type.image.ms)
+			bit = type.image.arrayed ? Query2DMSArray : Query2DMS;
+		else
+			bit = type.image.arrayed ? Query2DArray : Query2D;
+		break;
+
+	case Dim3D:
+		bit = Query3D;
+		break;
+
+	case DimCube:
+		bit = type.image.arrayed ? QueryCubeArray : QueryCube;
+		break;
+
+	case DimBuffer:
+		bit = QueryBuffer;
+		break;
+
+	default:
+		SPIRV_CROSS_THROW("Unsupported query type.");
+	}
+
+	switch (get<SPIRType>(type.image.type).basetype)
+	{
+	case SPIRType::Float:
+		bit += QueryTypeFloat;
+		break;
+
+	case SPIRType::Int:
+		bit += QueryTypeInt;
+		break;
+
+	case SPIRType::UInt:
+		bit += QueryTypeUInt;
+		break;
+
+	default:
+		SPIRV_CROSS_THROW("Unsupported query type.");
+	}
+
+	auto norm_state = image_format_to_normalized_state(type.image.format);
+	auto &variant = uav ? required_texture_size_variants
+	                          .uav[uint32_t(norm_state)][image_format_to_components(type.image.format) - 1] :
+	                      required_texture_size_variants.srv;
+
+	uint64_t mask = 1ull << bit;
+	if ((variant & mask) == 0)
+	{
+		force_recompile();
+		variant |= mask;
+	}
+}
+
+std::string CompilerHLSL::bitcast_expression(SPIRType::BaseType target_type, uint32_t arg)
+{
+	auto expr = to_expression(arg);
+	auto &src_type = expression_type(arg);
+	if (src_type.basetype != target_type)
+	{
+		auto target = src_type;
+		target.basetype = target_type;
+		expr = join(bitcast_glsl_op(target, src_type), "(", expr, ")");
+	}
+
+	return expr;
+}
+
+std::string CompilerHLSL::bitcast_expression(const SPIRType &target_type, SPIRType::BaseType expr_type,
+                                             const std::string &expr)
+{
+	if (target_type.basetype == expr_type)
+		return expr;
+
+	auto src_type = target_type;
+	src_type.basetype = expr_type;
+	return join(bitcast_glsl_op(target_type, src_type), "(", expr, ")");
+}
+
 #ifndef SPIRV_CROSS_WEBMIN
 CompilerHLSL::ShaderSubgroupSupportHelper::Result::Result()
 {
@@ -16599,66 +16751,6 @@ void CompilerHLSL::emit_legacy_uniform(const SPIRVariable &var)
 	}
 }
 
-string CompilerHLSL::bitcast_glsl_op(const SPIRType &out_type, const SPIRType &in_type)
-{
-	if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::Int)
-		return type_to_glsl(out_type);
-	else if (out_type.basetype == SPIRType::UInt64 && in_type.basetype == SPIRType::Int64)
-		return type_to_glsl(out_type);
-	else if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::Float)
-		return "asuint";
-	else if (out_type.basetype == SPIRType::Int && in_type.basetype == SPIRType::UInt)
-		return type_to_glsl(out_type);
-	else if (out_type.basetype == SPIRType::Int64 && in_type.basetype == SPIRType::UInt64)
-		return type_to_glsl(out_type);
-	else if (out_type.basetype == SPIRType::Int && in_type.basetype == SPIRType::Float)
-		return "asint";
-	else if (out_type.basetype == SPIRType::Float && in_type.basetype == SPIRType::UInt)
-		return "asfloat";
-	else if (out_type.basetype == SPIRType::Float && in_type.basetype == SPIRType::Int)
-		return "asfloat";
-	else if (out_type.basetype == SPIRType::Int64 && in_type.basetype == SPIRType::Double)
-		SPIRV_CROSS_THROW("Double to Int64 is not supported in HLSL.");
-	else if (out_type.basetype == SPIRType::UInt64 && in_type.basetype == SPIRType::Double)
-		SPIRV_CROSS_THROW("Double to UInt64 is not supported in HLSL.");
-	else if (out_type.basetype == SPIRType::Double && in_type.basetype == SPIRType::Int64)
-		return "asdouble";
-	else if (out_type.basetype == SPIRType::Double && in_type.basetype == SPIRType::UInt64)
-		return "asdouble";
-	else if (out_type.basetype == SPIRType::Half && in_type.basetype == SPIRType::UInt && in_type.vecsize == 1)
-	{
-		if (!requires_explicit_fp16_packing)
-		{
-			requires_explicit_fp16_packing = true;
-			force_recompile();
-		}
-		return "spvUnpackFloat2x16";
-	}
-	else if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::Half && in_type.vecsize == 2)
-	{
-		if (!requires_explicit_fp16_packing)
-		{
-			requires_explicit_fp16_packing = true;
-			force_recompile();
-		}
-		return "spvPackFloat2x16";
-	}
-	else if (out_type.basetype == SPIRType::UShort && in_type.basetype == SPIRType::Half)
-	{
-		if (hlsl_options.shader_model < 40)
-			SPIRV_CROSS_THROW("Half to UShort requires Shader Model 4.");
-		return "(" + type_to_glsl(out_type) + ")f32tof16";
-	}
-	else if (out_type.basetype == SPIRType::Half && in_type.basetype == SPIRType::UShort)
-	{
-		if (hlsl_options.shader_model < 40)
-			SPIRV_CROSS_THROW("UShort to Half requires Shader Model 4.");
-		return "(" + type_to_glsl(out_type) + ")f16tof32";
-	}
-	else
-		return "";
-}
-
 void CompilerHLSL::read_access_chain_array(const string &lhs, const SPIRAccessChain &chain)
 {
 	auto &type = get<SPIRType>(chain.basetype);
@@ -17533,77 +17625,6 @@ case OpGroupNonUniform##op: \
 	register_control_dependent_expression(id);
 }
 
-void CompilerHLSL::require_texture_query_variant(uint32_t var_id)
-{
-	if (const auto *var = maybe_get_backing_variable(var_id))
-		var_id = var->self;
-
-	auto &type = expression_type(var_id);
-	bool uav = type.image.sampled == 2;
-	if (hlsl_options.nonwritable_uav_texture_as_srv && has_decoration(var_id, DecorationNonWritable))
-		uav = false;
-
-	uint32_t bit = 0;
-	switch (type.image.dim)
-	{
-	case Dim1D:
-		bit = type.image.arrayed ? Query1DArray : Query1D;
-		break;
-
-	case Dim2D:
-		if (type.image.ms)
-			bit = type.image.arrayed ? Query2DMSArray : Query2DMS;
-		else
-			bit = type.image.arrayed ? Query2DArray : Query2D;
-		break;
-
-	case Dim3D:
-		bit = Query3D;
-		break;
-
-	case DimCube:
-		bit = type.image.arrayed ? QueryCubeArray : QueryCube;
-		break;
-
-	case DimBuffer:
-		bit = QueryBuffer;
-		break;
-
-	default:
-		SPIRV_CROSS_THROW("Unsupported query type.");
-	}
-
-	switch (get<SPIRType>(type.image.type).basetype)
-	{
-	case SPIRType::Float:
-		bit += QueryTypeFloat;
-		break;
-
-	case SPIRType::Int:
-		bit += QueryTypeInt;
-		break;
-
-	case SPIRType::UInt:
-		bit += QueryTypeUInt;
-		break;
-
-	default:
-		SPIRV_CROSS_THROW("Unsupported query type.");
-	}
-
-	auto norm_state = image_format_to_normalized_state(type.image.format);
-	auto &variant = uav ? required_texture_size_variants
-	                          .uav[uint32_t(norm_state)][image_format_to_components(type.image.format) - 1] :
-	                      required_texture_size_variants.srv;
-
-	uint64_t mask = 1ull << bit;
-	if ((variant & mask) == 0)
-	{
-		force_recompile();
-		variant |= mask;
-	}
-}
-
 VariableID CompilerHLSL::remap_num_workgroups_builtin()
 {
 	update_active_builtins();
@@ -17674,21 +17695,6 @@ bool CompilerHLSL::is_hlsl_resource_binding_used(ExecutionModel model, uint32_t
 	return itr != end(resource_bindings) && itr->second.second;
 }
 
-CompilerHLSL::BitcastType CompilerHLSL::get_bitcast_type(uint32_t result_type, uint32_t op0)
-{
-	auto &rslt_type = get<SPIRType>(result_type);
-	auto &expr_type = expression_type(op0);
-
-	if (rslt_type.basetype == SPIRType::BaseType::UInt64 && expr_type.basetype == SPIRType::BaseType::UInt &&
-	    expr_type.vecsize == 2)
-		return BitcastType::TypePackUint2x32;
-	else if (rslt_type.basetype == SPIRType::BaseType::UInt && rslt_type.vecsize == 2 &&
-	         expr_type.basetype == SPIRType::BaseType::UInt64)
-		return BitcastType::TypeUnpackUint64;
-
-	return BitcastType::TypeNormal;
-}
-
 bool CompilerHLSL::is_hlsl_force_storage_buffer_as_uav(ID id) const
 {
 	if (hlsl_options.force_storage_buffer_as_uav)
@@ -18442,31 +18448,6 @@ std::pair<std::string, uint32_t> CompilerHLSL::flattened_access_chain_offset(
 	return std::make_pair(expr, offset);
 }
 
-std::string CompilerHLSL::bitcast_expression(SPIRType::BaseType target_type, uint32_t arg)
-{
-	auto expr = to_expression(arg);
-	auto &src_type = expression_type(arg);
-	if (src_type.basetype != target_type)
-	{
-		auto target = src_type;
-		target.basetype = target_type;
-		expr = join(bitcast_glsl_op(target, src_type), "(", expr, ")");
-	}
-
-	return expr;
-}
-
-std::string CompilerHLSL::bitcast_expression(const SPIRType &target_type, SPIRType::BaseType expr_type,
-                                             const std::string &expr)
-{
-	if (target_type.basetype == expr_type)
-		return expr;
-
-	auto src_type = target_type;
-	src_type.basetype = expr_type;
-	return join(bitcast_glsl_op(target_type, src_type), "(", expr, ")");
-}
-
 void CompilerHLSL::emit_unrolled_unary_op(uint32_t result_type, uint32_t result_id, uint32_t operand, const char *op)
 {
 	auto &type = get<SPIRType>(result_type);
@@ -20274,6 +20255,7 @@ void CompilerHLSL::emit_spv_amd_gcn_shader_op(uint32_t result_type, uint32_t id,
 	}
 }
 #else
+
 CompilerHLSL::ShaderSubgroupSupportHelper::Result::Result()
 {
 	SPIRV_CROSS_INVALID_CALL();
@@ -20361,12 +20343,6 @@ void CompilerHLSL::emit_legacy_uniform(const SPIRVariable &)
 	SPIRV_CROSS_THROW("Invalid call.");
 }
 
-string CompilerHLSL::bitcast_glsl_op(const SPIRType &, const SPIRType &)
-{
-	SPIRV_CROSS_INVALID_CALL();
-	SPIRV_CROSS_THROW("Invalid call.");
-}
-
 void CompilerHLSL::read_access_chain_array(const string &, const SPIRAccessChain &)
 {
 	SPIRV_CROSS_INVALID_CALL();
@@ -20425,12 +20401,6 @@ void CompilerHLSL::emit_subgroup_op(const Instruction &)
 	SPIRV_CROSS_THROW("Invalid call.");
 }
 
-void CompilerHLSL::require_texture_query_variant(uint32_t)
-{
-	SPIRV_CROSS_INVALID_CALL();
-	SPIRV_CROSS_THROW("Invalid call.");
-}
-
 VariableID CompilerHLSL::remap_num_workgroups_builtin()
 {
 	SPIRV_CROSS_INVALID_CALL();
@@ -20461,12 +20431,6 @@ bool CompilerHLSL::is_hlsl_resource_binding_used(ExecutionModel, uint32_t, uint3
 	SPIRV_CROSS_THROW("Invalid call.");
 }
 
-CompilerHLSL::BitcastType CompilerHLSL::get_bitcast_type(uint32_t, uint32_t)
-{
-	SPIRV_CROSS_INVALID_CALL();
-	SPIRV_CROSS_THROW("Invalid call.");
-}
-
 bool CompilerHLSL::is_hlsl_force_storage_buffer_as_uav(ID) const
 {
 	SPIRV_CROSS_INVALID_CALL();
@@ -20553,19 +20517,6 @@ std::pair<std::string, uint32_t> CompilerHLSL::flattened_access_chain_offset(
 	SPIRV_CROSS_THROW("Invalid call.");
 }
 
-std::string CompilerHLSL::bitcast_expression(SPIRType::BaseType, uint32_t)
-{
-	SPIRV_CROSS_INVALID_CALL();
-	SPIRV_CROSS_THROW("Invalid call.");
-}
-
-std::string CompilerHLSL::bitcast_expression(const SPIRType &, SPIRType::BaseType,
-                                             const std::string &)
-{
-	SPIRV_CROSS_INVALID_CALL();
-	SPIRV_CROSS_THROW("Invalid call.");
-}
-
 void CompilerHLSL::emit_unrolled_unary_op(uint32_t, uint32_t, uint32_t, const char *)
 {
 	SPIRV_CROSS_INVALID_CALL();

package/shared/BabylonNative/deps/urllib-src/CMakeLists.txt

@@ -7,13 +7,13 @@ include(FetchContent)
 # --------------------------------------------------
 FetchContent_Declare(arcana.cpp
     GIT_REPOSITORY https://github.com/microsoft/arcana.cpp.git
-    GIT_TAG        c726dbe58713eda65bfb139c257093c43479b894)
+    GIT_TAG        7c6be8aaa29effbc8ee1a2217388fb6e399150d2)
 FetchContent_Declare(AndroidExtensions
-    GIT_REPOSITORY https://github.com/bghgary/AndroidExtensions.git
-    GIT_TAG        c84cb305205338b6fd6ff121a0349a810967bbc8)
+    GIT_REPOSITORY https://github.com/BabylonJS/AndroidExtensions.git
+    GIT_TAG        2d5af72259cc73e5f249d3c99bee2010be9cb042)
 FetchContent_Declare(CMakeExtensions
     GIT_REPOSITORY https://github.com/BabylonJS/CMakeExtensions.git
-    GIT_TAG ea28b7689530bfdc4905806f27ecf7e8ed4b5419)
+    GIT_TAG dc750e7f69dad76779419df6442f834c57a30a1f)
 FetchContent_Declare(ios-cmake
     GIT_REPOSITORY https://github.com/leetal/ios-cmake.git
     GIT_TAG 4.4.1)
@@ -38,7 +38,7 @@ endif()
 
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 if(ANDROID)
@@ -96,8 +96,7 @@ target_link_libraries(UrlLib
     ${ADDITIONAL_LIBRARIES})
 
 if(APPLE)
-    set_target_properties(UrlLib PROPERTIES
-        XCODE_ATTRIBUTE_CLANG_ENABLE_OBJC_ARC YES)
+    enable_objc_arc(UrlLib)
     set_property(TARGET UrlLib PROPERTY UNITY_BUILD false)
 endif()
 

package/shared/BabylonNative/deps/urllib-src/Source/UrlRequest_Unix.cpp

@@ -87,7 +87,7 @@ namespace UrlLib
                         curl_check(curl_url_get(m_curlu, CURLUPART_PATH, &path, 0));
 
                         auto newPath = std::filesystem::path{exe}.parent_path() / host / (path + 1);
-                        curl_check(curl_url_set(m_curlu, CURLUPART_PATH, newPath.generic_u8string().data(), 0));
+                        curl_check(curl_url_set(m_curlu, CURLUPART_PATH, reinterpret_cast<const char*>(newPath.generic_u8string().data()), 0));
 
                         m_file = true;
                     }

package/shared/BabylonNative.cpp

@@ -83,7 +83,11 @@ namespace BabylonNative
 
         void UpdateView(WindowType window, size_t width, size_t height)
         {
+#if defined(__APPLE__)
+            m_graphicsConfig.Window = (Babylon::Graphics::WindowT)window.layer;
+#else
             m_graphicsConfig.Window = window;
+#endif
             m_graphicsConfig.Width = width;
             m_graphicsConfig.Height = height;
             UpdateGraphicsConfiguration();

package/shared/BabylonNative/Repo/Plugins/TestUtils/Source/Apple/TestUtilsImpl.mm

@@ -1,57 +0,0 @@
-#import "../TestUtilsImplData.h"
-
-// can't externalize variable with ObjC++. Using a function instead.
-int errorCode{};
-int GetExitCode()
-{
-    return errorCode;
-}
-
-namespace Babylon::Plugins::Internal
-{
-    void TestUtils::Exit(const Napi::CallbackInfo& info)
-    {
-        errorCode = info[0].As<Napi::Number>().Int32Value();
-#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
-        dispatch_async(dispatch_get_main_queue(), ^{
-            UIAlertController* alert = [UIAlertController alertControllerWithTitle:@"Validation Tests"
-                                            message:(errorCode == 0)?@"Success!":@"Errors: Check logs!"
-                                            preferredStyle:UIAlertControllerStyleAlert];
-
-            UIAlertAction* defaultAction = [UIAlertAction actionWithTitle:@"OK" style:UIAlertActionStyleDefault
-                handler:^(UIAlertAction * ) {}];
-
-            [alert addAction:defaultAction];
-            UIViewController *rootController = [[[[UIApplication sharedApplication]delegate] window] rootViewController];
-            [rootController presentViewController:alert animated:YES completion:nil];
-        });
-#else
-        dispatch_async(dispatch_get_main_queue(), ^{
-            [[m_implData->m_window window]close];
-        });
-#endif
-    }
-
-    void TestUtils::UpdateSize(const Napi::CallbackInfo& /*info*/)
-    {
-    }
-
-    void TestUtils::SetTitle(const Napi::CallbackInfo& /*info*/)
-    {
-    }
-
-    Napi::Value TestUtils::GetOutputDirectory(const Napi::CallbackInfo& info)
-    {
-        std::string path = getenv("HOME");
-        return Napi::Value::From(info.Env(), path);
-    }
-}
-
-namespace Babylon::Plugins::TestUtils
-{
-    void Initialize(Napi::Env env, Graphics::WindowT window)
-    {
-        auto implData{std::make_shared<Internal::TestUtils::ImplData>(window)};
-        Internal::TestUtils::CreateInstance(env, implData);
-    }
-}

package/shared/BabylonNative/Repo/Plugins/TestUtils/Source/TestUtilsImplData.h

@@ -1,18 +0,0 @@
-#pragma once
-#include <Babylon/Graphics/Device.h>
-#include "TestUtils.h"
-
-namespace Babylon::Plugins::Internal
-{
-    class TestUtils::ImplData final : public std::enable_shared_from_this<TestUtils::ImplData>
-    {
-    public:
-        ImplData(Graphics::WindowT window)
-            : m_window{window}
-        {
-        }
-
-        Graphics::WindowT m_window{};
-    };
-
-} // namespace