Skip to content

Commit 447a83a

Browse files
wcandillonwcandillon
committed
⬆️
1 parent d290b33 commit 447a83a

17 files changed

Lines changed: 366 additions & 253 deletions

‎packages/webgpu/cpp/dawn_logging.cpp‎

Lines changed: 122 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,122 @@
1+
#include <sstream>
2+
#include <string>
3+
4+
#ifdef __ANDROID__
5+
#include <android/log.h>
6+
#elif defined(__APPLE__)
7+
#include <os/log.h>
8+
#endif
9+
10+
namespace dawn {
11+
12+
enum class LogSeverity {
13+
Debug,
14+
Info,
15+
Warning,
16+
Error,
17+
};
18+
19+
// Forward declare to match Dawn's exact interface
20+
class LogMessage {
21+
public:
22+
explicit LogMessage(LogSeverity severity);
23+
~LogMessage();
24+
25+
LogMessage(LogMessage&& other);
26+
LogMessage& operator=(LogMessage&& other);
27+
28+
template <typename T>
29+
LogMessage& operator<<(T&& value) {
30+
mStream << value;
31+
return *this;
32+
}
33+
34+
private:
35+
LogMessage(const LogMessage& other) = delete;
36+
LogMessage& operator=(const LogMessage& other) = delete;
37+
38+
LogSeverity mSeverity;
39+
std::ostringstream mStream;
40+
};
41+
42+
// Implementation of LogMessage methods
43+
LogMessage::LogMessage(LogSeverity severity) : mSeverity(severity) {}
44+
45+
LogMessage::LogMessage(LogMessage&& other)
46+
: mSeverity(other.mSeverity), mStream(std::move(other.mStream)) {}
47+
48+
LogMessage& LogMessage::operator=(LogMessage&& other) {
49+
if (this != &other) {
50+
mSeverity = other.mSeverity;
51+
mStream = std::move(other.mStream);
52+
}
53+
return *this;
54+
}
55+
56+
LogMessage::~LogMessage() {
57+
std::string fullMessage = mStream.str();
58+
59+
if (fullMessage.empty()) {
60+
return;
61+
}
62+
63+
const char* severityName;
64+
switch (mSeverity) {
65+
case LogSeverity::Debug: severityName = "Debug"; break;
66+
case LogSeverity::Info: severityName = "Info"; break;
67+
case LogSeverity::Warning: severityName = "Warning"; break;
68+
case LogSeverity::Error: severityName = "Error"; break;
69+
default: severityName = "Unknown"; break;
70+
}
71+
72+
#ifdef __ANDROID__
73+
int androidPriority;
74+
switch (mSeverity) {
75+
case LogSeverity::Debug: androidPriority = ANDROID_LOG_DEBUG; break;
76+
case LogSeverity::Info: androidPriority = ANDROID_LOG_INFO; break;
77+
case LogSeverity::Warning: androidPriority = ANDROID_LOG_WARN; break;
78+
case LogSeverity::Error: androidPriority = ANDROID_LOG_ERROR; break;
79+
default: androidPriority = ANDROID_LOG_ERROR; break;
80+
}
81+
__android_log_print(androidPriority, "ReactNativeWebGPU", "%s: %s", severityName, fullMessage.c_str());
82+
#elif defined(__APPLE__)
83+
os_log_type_t logType;
84+
switch (mSeverity) {
85+
case LogSeverity::Debug: logType = OS_LOG_TYPE_DEBUG; break;
86+
case LogSeverity::Info: logType = OS_LOG_TYPE_INFO; break;
87+
case LogSeverity::Warning: logType = OS_LOG_TYPE_DEFAULT; break;
88+
case LogSeverity::Error: logType = OS_LOG_TYPE_ERROR; break;
89+
default: logType = OS_LOG_TYPE_ERROR; break;
90+
}
91+
os_log_with_type(OS_LOG_DEFAULT, logType, "[ReactNativeWebGPU] %s: %s", severityName, fullMessage.c_str());
92+
#else
93+
FILE* outputStream = (mSeverity == LogSeverity::Warning || mSeverity == LogSeverity::Error) ? stderr : stdout;
94+
fprintf(outputStream, "[ReactNativeWebGPU] %s: %s\n", severityName, fullMessage.c_str());
95+
fflush(outputStream);
96+
#endif
97+
}
98+
99+
// Factory functions
100+
LogMessage DebugLog() {
101+
return LogMessage(LogSeverity::Debug);
102+
}
103+
104+
LogMessage InfoLog() {
105+
return LogMessage(LogSeverity::Info);
106+
}
107+
108+
LogMessage WarningLog() {
109+
return LogMessage(LogSeverity::Warning);
110+
}
111+
112+
LogMessage ErrorLog() {
113+
return LogMessage(LogSeverity::Error);
114+
}
115+
116+
LogMessage DebugLog(const char* file, const char* function, int line) {
117+
LogMessage message = DebugLog();
118+
message << file << ":" << line << "(" << function << ")";
119+
return message;
120+
}
121+
122+
} // namespace dawn

‎packages/webgpu/cpp/rnwgpu/SurfaceRegistry.h‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -83,10 +83,10 @@ class SurfaceInfo {
8383
auto device = config.device;
8484
wgpu::CommandEncoder encoder = device.CreateCommandEncoder(&encoderDesc);
8585

86-
wgpu::ImageCopyTexture sourceTexture = {};
86+
wgpu::TexelCopyTextureInfo sourceTexture = {};
8787
sourceTexture.texture = texture;
8888

89-
wgpu::ImageCopyTexture destinationTexture = {};
89+
wgpu::TexelCopyTextureInfo destinationTexture = {};
9090
wgpu::SurfaceTexture surfaceTexture;
9191
surface.GetCurrentTexture(&surfaceTexture);
9292
destinationTexture.texture = surfaceTexture.texture;

‎packages/webgpu/cpp/rnwgpu/api/Convertors.h‎

Lines changed: 38 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -309,7 +309,7 @@ class Convertor {
309309
Convert(out.label, in.label);
310310
}
311311

312-
[[nodiscard]] bool Convert(wgpu::ComputePassTimestampWrites &out,
312+
[[nodiscard]] bool Convert(wgpu::PassTimestampWrites &out,
313313
const GPUComputePassTimestampWrites &in) {
314314
return Convert(out.querySet, in.querySet) &&
315315
Convert(out.beginningOfPassWriteIndex,
@@ -348,74 +348,70 @@ class Convertor {
348348

349349
if (in.requiredLimits.has_value()) {
350350
const auto &limits = in.requiredLimits.value();
351-
auto *requiredLimits = Allocate<wgpu::RequiredLimits>();
351+
auto *requiredLimits = Allocate<wgpu::Limits>();
352352
for (const auto &[key, value] : limits) {
353353
if (key == "maxTextureDimension1D") {
354-
requiredLimits->limits.maxTextureDimension1D = value;
354+
requiredLimits->maxTextureDimension1D = value;
355355
} else if (key == "maxTextureDimension2D") {
356-
requiredLimits->limits.maxTextureDimension2D = value;
356+
requiredLimits->maxTextureDimension2D = value;
357357
} else if (key == "maxTextureDimension3D") {
358-
requiredLimits->limits.maxTextureDimension3D = value;
358+
requiredLimits->maxTextureDimension3D = value;
359359
} else if (key == "maxTextureArrayLayers") {
360-
requiredLimits->limits.maxTextureArrayLayers = value;
360+
requiredLimits->maxTextureArrayLayers = value;
361361
} else if (key == "maxBindGroups") {
362-
requiredLimits->limits.maxBindGroups = value;
362+
requiredLimits->maxBindGroups = value;
363363
} else if (key == "maxBindGroupsPlusVertexBuffers") {
364-
requiredLimits->limits.maxBindGroupsPlusVertexBuffers = value;
364+
requiredLimits->maxBindGroupsPlusVertexBuffers = value;
365365
} else if (key == "maxBindingsPerBindGroup") {
366-
requiredLimits->limits.maxBindingsPerBindGroup = value;
366+
requiredLimits->maxBindingsPerBindGroup = value;
367367
} else if (key == "maxDynamicUniformBuffersPerPipelineLayout") {
368-
requiredLimits->limits.maxDynamicUniformBuffersPerPipelineLayout =
369-
value;
368+
requiredLimits->maxDynamicUniformBuffersPerPipelineLayout = value;
370369
} else if (key == "maxDynamicStorageBuffersPerPipelineLayout") {
371-
requiredLimits->limits.maxDynamicStorageBuffersPerPipelineLayout =
372-
value;
370+
requiredLimits->maxDynamicStorageBuffersPerPipelineLayout = value;
373371
} else if (key == "maxSampledTexturesPerShaderStage") {
374-
requiredLimits->limits.maxSampledTexturesPerShaderStage = value;
372+
requiredLimits->maxSampledTexturesPerShaderStage = value;
375373
} else if (key == "maxSamplersPerShaderStage") {
376-
requiredLimits->limits.maxSamplersPerShaderStage = value;
374+
requiredLimits->maxSamplersPerShaderStage = value;
377375
} else if (key == "maxStorageBuffersPerShaderStage") {
378-
requiredLimits->limits.maxStorageBuffersPerShaderStage = value;
376+
requiredLimits->maxStorageBuffersPerShaderStage = value;
379377
} else if (key == "maxStorageTexturesPerShaderStage") {
380-
requiredLimits->limits.maxStorageTexturesPerShaderStage = value;
378+
requiredLimits->maxStorageTexturesPerShaderStage = value;
381379
} else if (key == "maxUniformBuffersPerShaderStage") {
382-
requiredLimits->limits.maxUniformBuffersPerShaderStage = value;
380+
requiredLimits->maxUniformBuffersPerShaderStage = value;
383381
} else if (key == "maxUniformBufferBindingSize") {
384-
requiredLimits->limits.maxUniformBufferBindingSize = value;
382+
requiredLimits->maxUniformBufferBindingSize = value;
385383
} else if (key == "maxStorageBufferBindingSize") {
386-
requiredLimits->limits.maxStorageBufferBindingSize = value;
384+
requiredLimits->maxStorageBufferBindingSize = value;
387385
} else if (key == "minUniformBufferOffsetAlignment") {
388-
requiredLimits->limits.minUniformBufferOffsetAlignment = value;
386+
requiredLimits->minUniformBufferOffsetAlignment = value;
389387
} else if (key == "minStorageBufferOffsetAlignment") {
390-
requiredLimits->limits.minStorageBufferOffsetAlignment = value;
388+
requiredLimits->minStorageBufferOffsetAlignment = value;
391389
} else if (key == "maxVertexBuffers") {
392-
requiredLimits->limits.maxVertexBuffers = value;
390+
requiredLimits->maxVertexBuffers = value;
393391
} else if (key == "maxBufferSize") {
394-
requiredLimits->limits.maxBufferSize = value;
392+
requiredLimits->maxBufferSize = value;
395393
} else if (key == "maxVertexAttributes") {
396-
requiredLimits->limits.maxVertexAttributes = value;
394+
requiredLimits->maxVertexAttributes = value;
397395
} else if (key == "maxVertexBufferArrayStride") {
398-
requiredLimits->limits.maxVertexBufferArrayStride = value;
399-
} else if (key == "maxInterStageShaderComponents") {
400-
requiredLimits->limits.maxInterStageShaderComponents = value;
396+
requiredLimits->maxVertexBufferArrayStride = value;
401397
} else if (key == "maxInterStageShaderVariables") {
402-
requiredLimits->limits.maxInterStageShaderVariables = value;
398+
requiredLimits->maxInterStageShaderVariables = value;
403399
} else if (key == "maxColorAttachments") {
404-
requiredLimits->limits.maxColorAttachments = value;
400+
requiredLimits->maxColorAttachments = value;
405401
} else if (key == "maxColorAttachmentBytesPerSample") {
406-
requiredLimits->limits.maxColorAttachmentBytesPerSample = value;
402+
requiredLimits->maxColorAttachmentBytesPerSample = value;
407403
} else if (key == "maxComputeWorkgroupStorageSize") {
408-
requiredLimits->limits.maxComputeWorkgroupStorageSize = value;
404+
requiredLimits->maxComputeWorkgroupStorageSize = value;
409405
} else if (key == "maxComputeInvocationsPerWorkgroup") {
410-
requiredLimits->limits.maxComputeInvocationsPerWorkgroup = value;
406+
requiredLimits->maxComputeInvocationsPerWorkgroup = value;
411407
} else if (key == "maxComputeWorkgroupSizeX") {
412-
requiredLimits->limits.maxComputeWorkgroupSizeX = value;
408+
requiredLimits->maxComputeWorkgroupSizeX = value;
413409
} else if (key == "maxComputeWorkgroupSizeY") {
414-
requiredLimits->limits.maxComputeWorkgroupSizeY = value;
410+
requiredLimits->maxComputeWorkgroupSizeY = value;
415411
} else if (key == "maxComputeWorkgroupSizeZ") {
416-
requiredLimits->limits.maxComputeWorkgroupSizeZ = value;
412+
requiredLimits->maxComputeWorkgroupSizeZ = value;
417413
} else if (key == "maxComputeWorkgroupsPerDimension") {
418-
requiredLimits->limits.maxComputeWorkgroupsPerDimension = value;
414+
requiredLimits->maxComputeWorkgroupsPerDimension = value;
419415
}
420416
}
421417
out.requiredLimits = requiredLimits;
@@ -452,7 +448,7 @@ class Convertor {
452448
Convert(out.constants, out.constantCount, in.constants);
453449
}
454450

455-
[[nodiscard]] bool Convert(wgpu::ImageCopyBuffer &out,
451+
[[nodiscard]] bool Convert(wgpu::TexelCopyBufferInfo &out,
456452
const GPUImageCopyBuffer &in) {
457453
out = {};
458454
out.buffer = in.buffer->get();
@@ -461,13 +457,13 @@ class Convertor {
461457
Convert(out.layout.rowsPerImage, in.rowsPerImage);
462458
}
463459

464-
[[nodiscard]] bool Convert(wgpu::ImageCopyTexture &out,
460+
[[nodiscard]] bool Convert(wgpu::TexelCopyTextureInfo &out,
465461
const GPUImageCopyTexture &in) {
466462
return Convert(out.origin, in.origin) && Convert(out.texture, in.texture) &&
467463
Convert(out.mipLevel, in.mipLevel) && Convert(out.aspect, in.aspect);
468464
}
469465

470-
[[nodiscard]] bool Convert(wgpu::TextureDataLayout &out,
466+
[[nodiscard]] bool Convert(wgpu::TexelCopyBufferLayout &out,
471467
const GPUImageDataLayout &in) {
472468
out = {};
473469
return Convert(out.bytesPerRow, in.bytesPerRow) &&
@@ -502,7 +498,7 @@ class Convertor {
502498
Convert(out.cullMode, in.cullMode);
503499
}
504500

505-
[[nodiscard]] bool Convert(wgpu::ProgrammableStageDescriptor &out,
501+
[[nodiscard]] bool Convert(wgpu::ComputeState &out,
506502
const GPUProgrammableStage &in) {
507503
out = {};
508504
out.module = in.module->get();
@@ -554,7 +550,7 @@ class Convertor {
554550
Convert(out.stencilReadOnly, in.stencilReadOnly);
555551
}
556552

557-
[[nodiscard]] bool Convert(wgpu::RenderPassTimestampWrites &out,
553+
[[nodiscard]] bool Convert(wgpu::PassTimestampWrites &out,
558554
const GPURenderPassTimestampWrites &in) {
559555
return Convert(out.querySet, in.querySet) &&
560556
Convert(out.beginningOfPassWriteIndex,

‎packages/webgpu/cpp/rnwgpu/api/GPU.cpp‎

Lines changed: 42 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -27,15 +27,16 @@ GPU::requestAdapter(
2727
aOptions.backendType = kDefaultBackendType;
2828
wgpu::Adapter adapter = nullptr;
2929
_instance.RequestAdapter(
30-
&aOptions,
31-
[](WGPURequestAdapterStatus, WGPUAdapter cAdapter,
32-
const WGPUStringView message, void *userdata) {
30+
&aOptions, wgpu::CallbackMode::AllowProcessEvents,
31+
[](wgpu::RequestAdapterStatus status, wgpu::Adapter adapter,
32+
wgpu::StringView message, wgpu::Adapter *userdata) {
3333
if (message.length) {
3434
fprintf(stderr, "%s", message.data);
3535
return;
3636
}
37-
*static_cast<wgpu::Adapter *>(userdata) =
38-
wgpu::Adapter::Acquire(cAdapter);
37+
if (status == wgpu::RequestAdapterStatus::Success) {
38+
*userdata = std::move(adapter);
39+
}
3940
},
4041
&adapter);
4142
if (!adapter) {
@@ -47,43 +48,43 @@ GPU::requestAdapter(
4748
}
4849

4950
std::unordered_set<std::string> GPU::getWgslLanguageFeatures() {
50-
auto count = _instance.EnumerateWGSLLanguageFeatures(nullptr);
51-
std::vector<wgpu::WGSLFeatureName> features(count);
52-
_instance.EnumerateWGSLLanguageFeatures(features.data());
51+
// auto count = _instance.EnumerateWGSLLanguageFeatures(nullptr);
52+
// std::vector<wgpu::WGSLFeatureName> features(count);
53+
///_instance.EnumerateWGSLLanguageFeatures(features.data());
5354
std::unordered_set<std::string> result;
54-
for (auto feature : features) {
55-
std::string name;
56-
switch (feature) {
57-
case wgpu::WGSLFeatureName::ReadonlyAndReadwriteStorageTextures:
58-
name = "readonly_and_readwrite_storage_textures";
59-
break;
60-
case wgpu::WGSLFeatureName::Packed4x8IntegerDotProduct:
61-
name = "packed_4x8_integer_dot_product";
62-
break;
63-
case wgpu::WGSLFeatureName::UnrestrictedPointerParameters:
64-
name = "unrestricted_pointer_parameters";
65-
break;
66-
case wgpu::WGSLFeatureName::PointerCompositeAccess:
67-
name = "pointer_composite_access";
68-
break;
69-
case wgpu::WGSLFeatureName::ChromiumTestingUnimplemented:
70-
name = "chromium_testing_unimplemented";
71-
break;
72-
case wgpu::WGSLFeatureName::ChromiumTestingUnsafeExperimental:
73-
name = "chromium_testing_unsafe_experimental";
74-
break;
75-
case wgpu::WGSLFeatureName::ChromiumTestingExperimental:
76-
name = "chromium_testing_experimental";
77-
break;
78-
case wgpu::WGSLFeatureName::ChromiumTestingShippedWithKillswitch:
79-
name = "chromium_testing_shipped_with_killswitch";
80-
break;
81-
case wgpu::WGSLFeatureName::ChromiumTestingShipped:
82-
name = "chromium_testing_shipped";
83-
break;
84-
}
85-
result.insert(name);
86-
}
55+
// for (auto feature : features) {
56+
// std::string name;
57+
// switch (feature) {
58+
// case wgpu::WGPUFeatureName::ReadonlyAndReadwriteStorageTextures:
59+
// name = "readonly_and_readwrite_storage_textures";
60+
// break;
61+
// case wgpu::WGPUFeatureName::Packed4x8IntegerDotProduct:
62+
// name = "packed_4x8_integer_dot_product";
63+
// break;
64+
// case wgpu::WGPUFeatureName::UnrestrictedPointerParameters:
65+
// name = "unrestricted_pointer_parameters";
66+
// break;
67+
// case wgpu::WGPUFeatureName::PointerCompositeAccess:
68+
// name = "pointer_composite_access";
69+
// break;
70+
// case wgpu::WGPUFeatureName::ChromiumTestingUnimplemented:
71+
// name = "chromium_testing_unimplemented";
72+
// break;
73+
// case wgpu::WGPUFeatureName::ChromiumTestingUnsafeExperimental:
74+
// name = "chromium_testing_unsafe_experimental";
75+
// break;
76+
// case wgpu::WGPUFeatureName::ChromiumTestingExperimental:
77+
// name = "chromium_testing_experimental";
78+
// break;
79+
// case wgpu::WGPUFeatureName::ChromiumTestingShippedWithKillswitch:
80+
// name = "chromium_testing_shipped_with_killswitch";
81+
// break;
82+
// case wgpu::WGPUFeatureName::ChromiumTestingShipped:
83+
// name = "chromium_testing_shipped";
84+
// break;
85+
// }
86+
// result.insert(name);
87+
// }
8788
return result;
8889
}
8990

0 commit comments

Comments
 (0)