WIP

Author: davnotdev

drivers/webgpu/SCsub

@@ -20,5 +20,5 @@ env.drivers_sources += driver_obj
 # Needed to force rebuilding the driver files when the thirdparty code is updated.
 env.Depends(driver_obj, thirdparty_obj)
 
-env.Prepend(LIBS=["wgpu_native"])
+# env.Prepend(LIBS=["wgpu_native"])
 env.Prepend(LIBPATH=[thirdparty_dir])

drivers/webgpu/rendering_context_driver_webgpu.cpp

@@ -15,13 +15,19 @@ static void handle_request_adapter(WGPURequestAdapterStatus status,
 			status != WGPURequestAdapterStatus_Success, (void)0,
 			vformat("Failed to get wgpu adapter: %s", message.data));
 
+	/*
 	WGPUAdapterInfo info;
 	wgpuAdapterGetInfo(adapter, &info);
 
 	RenderingContextDriver::Device device;
 	device.name = String(info.device.data);
 	device.vendor = info.vendorID;
 	device.type = (RenderingContextDriver::DeviceType)info.adapterType;
+	*/
+	RenderingContextDriver::Device device;
+	device.name = String("name");
+	device.vendor = RenderingContextDriver::Vendor::VENDOR_UNKNOWN;
+	device.type = RenderingContextDriver::DeviceType::DEVICE_TYPE_INTEGRATED_GPU;
 
 	RenderingContextDriverWebGpu *context = (RenderingContextDriverWebGpu *)userdata;
 	context->adapter_push_back(
@@ -42,7 +48,11 @@ RenderingContextDriverWebGpu::~RenderingContextDriverWebGpu() {
 }
 
 Error RenderingContextDriverWebGpu::initialize() {
-	instance = wgpuCreateInstance(nullptr);
+	WGPUInstanceDescriptor instance_desc = (WGPUInstanceDescriptor){
+		.features = (WGPUInstanceCapabilities){
+				.timedWaitAnyEnable = true }
+	};
+	instance = wgpuCreateInstance(&instance_desc);
 
 	WGPURequestAdapterOptions adapter_options = {};
 	WGPURequestAdapterCallbackInfo adapter_callback_info = {
@@ -53,18 +63,19 @@ Error RenderingContextDriverWebGpu::initialize() {
 
 	// There is no way to request all adapters, so we just get the high and low power ones.
 
+	WGPUFutureWaitInfo adapter_futures[2] = {};
+
 	adapter_options.powerPreference = WGPUPowerPreference::WGPUPowerPreference_HighPerformance;
-	wgpuInstanceRequestAdapter(instance,
+	adapter_futures[0].future = wgpuInstanceRequestAdapter(instance,
 			&adapter_options,
 			adapter_callback_info);
 
 	adapter_options.powerPreference = WGPUPowerPreference::WGPUPowerPreference_LowPower;
-	wgpuInstanceRequestAdapter(instance,
-		&adapter_options,
-		adapter_callback_info);
+	adapter_futures[1].future = wgpuInstanceRequestAdapter(instance,
+			&adapter_options,
+			adapter_callback_info);
 
-	// NOTE: Currently unimplemented in wgpu.
-	// wgpuInstanceProcessEvents(instance);
+	wgpuInstanceWaitAny(instance, 2, adapter_futures, UINT64_MAX);
 
 	return OK;
 }
@@ -83,7 +94,7 @@ bool RenderingContextDriverWebGpu::device_supports_present(uint32_t p_device_ind
 	DEV_ASSERT(p_device_index < adapters.size());
 	WGPUAdapter adapter = adapters[p_device_index];
 	Surface *surface = (Surface *)p_surface;
-	WGPUSurfaceCapabilities caps;
+	WGPUSurfaceCapabilities caps = { nullptr };
 	wgpuSurfaceGetCapabilities(surface->surface, adapter, &caps);
 	return caps.formatCount != 0;
 }
@@ -97,8 +108,11 @@ void RenderingContextDriverWebGpu::driver_free(RenderingDeviceDriver *p_driver)
 }
 
 RenderingContextDriver::SurfaceID RenderingContextDriverWebGpu::surface_create(const void *p_platform_data) {
+#ifndef WEB_ENABLED
 	DEV_ASSERT(false && "Surface creation should not be called on the platform-agnostic version of the driver.");
-	return SurfaceID();
+#endif
+	// Well, it can't just be 0.
+	return SurfaceID(1);
 }
 
 void RenderingContextDriverWebGpu::surface_set_size(SurfaceID p_surface, uint32_t p_width, uint32_t p_height) {

drivers/webgpu/rendering_device_driver_webgpu.cpp

@@ -39,6 +39,7 @@ Error RenderingDeviceDriverWebGpu::initialize(uint32_t p_device_index, uint32_t
 	WGPUFeatureName required_features[] = {
 		WGPUFeatureName_Depth32FloatStencil8,
 
+		/*
 		// Waiting on WebGPU spec, see https://github.com/gpuweb/gpuweb/blob/main/proposals/push-constants.md
 		(WGPUFeatureName)WGPUNativeFeature_PushConstants,
 		// Need to implement shader translation (via naga or tint)
@@ -52,6 +53,7 @@ Error RenderingDeviceDriverWebGpu::initialize(uint32_t p_device_index, uint32_t
 		(WGPUFeatureName)WGPUNativeFeature_TextureBindingArray,
 		(WGPUFeatureName)WGPUNativeFeature_StorageResourceBindingArray,
 		(WGPUFeatureName)WGPUNativeFeature_BufferBindingArray,
+		*/
 
 		// Currently avoidable
 		// (WGPUFeatureName)WGPUNativeFeature_VertexWritableStorage,
@@ -71,24 +73,29 @@ Error RenderingDeviceDriverWebGpu::initialize(uint32_t p_device_index, uint32_t
 
 	WGPULimits required_limits =
 			(WGPULimits){
-				.nextInChain = (WGPUChainedStructOut *)&required_native_limits,
+				// .nextInChain = (WGPUChainedStructOut *)&required_native_limits,
 				.maxTextureDimension1D = WGPU_LIMIT_U32_UNDEFINED,
 				.maxTextureDimension2D = WGPU_LIMIT_U32_UNDEFINED,
 				.maxTextureDimension3D = WGPU_LIMIT_U32_UNDEFINED,
 				.maxTextureArrayLayers = WGPU_LIMIT_U32_UNDEFINED,
-				.maxBindGroups = 5,
+				.maxBindGroups = WGPU_LIMIT_U32_UNDEFINED,
+				// .maxBindGroups = 5,
 				.maxBindGroupsPlusVertexBuffers = WGPU_LIMIT_U32_UNDEFINED,
 				.maxBindingsPerBindGroup = WGPU_LIMIT_U32_UNDEFINED,
 				.maxDynamicUniformBuffersPerPipelineLayout = WGPU_LIMIT_U32_UNDEFINED,
 				.maxDynamicStorageBuffersPerPipelineLayout = WGPU_LIMIT_U32_UNDEFINED,
-				.maxSampledTexturesPerShaderStage = 49,
+				.maxSampledTexturesPerShaderStage = WGPU_LIMIT_U32_UNDEFINED,
+				// .maxSampledTexturesPerShaderStage = 49,
 				.maxSamplersPerShaderStage = WGPU_LIMIT_U32_UNDEFINED,
 				.maxStorageBuffersPerShaderStage = WGPU_LIMIT_U32_UNDEFINED,
-				.maxStorageTexturesPerShaderStage = 15,
+				.maxStorageTexturesPerShaderStage = WGPU_LIMIT_U32_UNDEFINED,
+				// .maxStorageTexturesPerShaderStage = 15,
+				.maxUniformBuffersPerShaderStage = WGPU_LIMIT_U32_UNDEFINED,
 				// NOTE: I'm not sure why Godot uses 32768 + 272 of these...
-				.maxUniformBuffersPerShaderStage = 32768 + 272,
+				// .maxUniformBuffersPerShaderStage = 32768 + 272,
 				// NOTE: This is my system's max buffer size, needed for some godot examples.
-				.maxUniformBufferBindingSize = 2147483648,
+				.maxUniformBufferBindingSize = WGPU_LIMIT_U64_UNDEFINED,
+				// .maxUniformBufferBindingSize = 2147483648,
 				.maxStorageBufferBindingSize = WGPU_LIMIT_U64_UNDEFINED,
 				.minUniformBufferOffsetAlignment = WGPU_LIMIT_U32_UNDEFINED,
 				.minStorageBufferOffsetAlignment = WGPU_LIMIT_U32_UNDEFINED,
@@ -117,7 +124,11 @@ Error RenderingDeviceDriverWebGpu::initialize(uint32_t p_device_index, uint32_t
 		.callback = handle_request_device,
 		.userdata1 = &this->device,
 	};
-	wgpuAdapterRequestDevice(adapter, &device_desc, device_callback_info);
+	WGPUFutureWaitInfo request_device_future = {};
+	request_device_future.future = wgpuAdapterRequestDevice(adapter, &device_desc, device_callback_info);
+
+	wgpuInstanceWaitAny(this->context_driver->instance_get(), 1, &request_device_future, UINT64_MAX);
+
 	ERR_FAIL_COND_V(!this->device, FAILED);
 
 	queue = wgpuDeviceGetQueue(device);

platform/web/detect.py

@@ -236,7 +236,9 @@ def configure(env: "SConsEnvironment"):
 
     if env["webgpu"] and env["use_webgpu"]:
         env.AppendUnique(CPPDEFINES=["WEBGPU_ENABLED", "RD_ENABLED"])
-        env.Append(LINKFLAGS=["-sUSE_WEBGPU"])
+        env.AppendUnique(CPPDEFINES=["EMCC_DEBUG=1"])
+        env.Append(LINKFLAGS=["--use-port=emdawnwebgpu", "-sJSPI"])
+        env.Append(CCFLAGS=["-g"])
 
     if env["javascript_eval"]:
         env.Append(CPPDEFINES=["JAVASCRIPT_EVAL_ENABLED"])

platform/web/display_server_web.cpp

@@ -42,6 +42,10 @@
 #include "drivers/gles3/rasterizer_gles3.h"
 #endif
 
+#ifdef WEBGPU_ENABLED
+#include "servers/rendering/renderer_rd/renderer_compositor_rd.h"
+#endif
+
 #include <emscripten.h>
 #include <png.h>
 
@@ -1129,8 +1133,22 @@ DisplayServerWeb::DisplayServerWeb(const String &p_rendering_driver, WindowMode
 	rendering_context = memnew(RenderingContextDriverWebGpu);
 	rendering_context->initialize();
 
-	rendering_device = rendering_context->driver_create();
-	rendering_device->initialize(0, 2);
+	rendering_context->window_create(MAIN_WINDOW_ID, nullptr);
+
+	rendering_device = memnew(RenderingDevice);
+	if (rendering_device->initialize(rendering_context, MAIN_WINDOW_ID) != OK) {
+		memdelete(rendering_device);
+		rendering_device = nullptr;
+		memdelete(rendering_context);
+		rendering_context = nullptr;
+		r_error = ERR_UNAVAILABLE;
+		return;
+	}
+	rendering_device->screen_create(MAIN_WINDOW_ID);
+
+	RendererCompositorRD::make_current();
+
+	RendererCompositorRD::make_current();
 #else
 	RasterizerDummy::make_current();
 #endif

platform/web/display_server_web.h

@@ -35,6 +35,8 @@
 #include "godot_js.h"
 
 #ifdef WEBGPU_ENABLED
+#include "servers/rendering/rendering_device.h"
+
 #include "drivers/webgpu/rendering_device_driver_webgpu.h"
 #include "drivers/webgpu/rendering_context_driver_webgpu.h"
 #endif
@@ -64,8 +66,8 @@ class DisplayServerWeb : public DisplayServer {
 #endif
 
 #ifdef RD_ENABLED
-	RenderingContextDriver* rendering_context;
-	RenderingDeviceDriver* rendering_device;
+	RenderingContextDriver* rendering_context = nullptr;
+	RenderingDevice* rendering_device = nullptr;
 #endif
 
 	HashMap<int, CharString> utterance_ids;

servers/rendering/rendering_device.cpp

@@ -37,6 +37,8 @@
 #include "core/config/project_settings.h"
 #include "core/io/dir_access.h"
 
+#include <emscripten.h>
+
 #define FORCE_SEPARATE_PRESENT_QUEUE 0
 #define PRINT_FRAMEBUFFER_FORMAT 0