| // Copyright 2021 The Dawn & Tint Authors |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are met: |
| // |
| // 1. Redistributions of source code must retain the above copyright notice, this |
| // list of conditions and the following disclaimer. |
| // |
| // 2. Redistributions in binary form must reproduce the above copyright notice, |
| // this list of conditions and the following disclaimer in the documentation |
| // and/or other materials provided with the distribution. |
| // |
| // 3. Neither the name of the copyright holder nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| #include "src/dawn/node/binding/GPUShaderModule.h" |
| |
| #include <memory> |
| #include <utility> |
| #include <vector> |
| |
| #include "src/dawn/node/binding/Converter.h" |
| |
| namespace wgpu::binding { |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // wgpu::bindings::GPUShaderModule |
| //////////////////////////////////////////////////////////////////////////////// |
| GPUShaderModule::GPUShaderModule(const wgpu::ShaderModuleDescriptor& desc, |
| wgpu::ShaderModule shader, |
| std::shared_ptr<AsyncRunner> async) |
| : shader_(std::move(shader)), async_(std::move(async)), label_(CopyLabel(desc.label)) {} |
| |
| interop::Promise<interop::Interface<interop::GPUCompilationInfo>> |
| GPUShaderModule::getCompilationInfo(Napi::Env env) { |
| struct GPUCompilationMessage : public interop::GPUCompilationMessage { |
| WGPUCompilationMessage message; |
| |
| explicit GPUCompilationMessage(const WGPUCompilationMessage& m) : message(m) {} |
| std::string getMessage(Napi::Env) override { return message.message; } |
| interop::GPUCompilationMessageType getType(Napi::Env) override { |
| switch (message.type) { |
| case WGPUCompilationMessageType_Error: |
| return interop::GPUCompilationMessageType::kError; |
| case WGPUCompilationMessageType_Warning: |
| return interop::GPUCompilationMessageType::kWarning; |
| case WGPUCompilationMessageType_Info: |
| return interop::GPUCompilationMessageType::kInfo; |
| default: |
| UNREACHABLE("unrecognized handled compilation message type", message.type); |
| } |
| } |
| uint64_t getLineNum(Napi::Env) override { return message.lineNum; } |
| uint64_t getLinePos(Napi::Env) override { return message.utf16LinePos; } |
| uint64_t getOffset(Napi::Env) override { return message.utf16Offset; } |
| uint64_t getLength(Napi::Env) override { return message.utf16Length; } |
| }; |
| |
| using Messages = std::vector<interop::Interface<interop::GPUCompilationMessage>>; |
| |
| struct GPUCompilationInfo : public interop::GPUCompilationInfo { |
| std::vector<Napi::ObjectReference> messages; |
| |
| GPUCompilationInfo(Napi::Env env, Messages msgs) { |
| messages.reserve(msgs.size()); |
| for (auto& msg : msgs) { |
| messages.emplace_back(Napi::Persistent(Napi::Object(env, msg))); |
| } |
| } |
| Messages getMessages(Napi::Env) override { |
| Messages out; |
| out.reserve(messages.size()); |
| for (auto& msg : messages) { |
| out.emplace_back(msg.Value()); |
| } |
| return out; |
| } |
| }; |
| |
| auto ctx = std::make_unique<AsyncContext<interop::Interface<interop::GPUCompilationInfo>>>( |
| env, PROMISE_INFO, async_); |
| auto promise = ctx->promise; |
| |
| shader_.GetCompilationInfo( |
| wgpu::CallbackMode::AllowProcessEvents, |
| [ctx = std::move(ctx)](wgpu::CompilationInfoRequestStatus status, |
| wgpu::CompilationInfo const* compilationInfo) { |
| Messages messages(compilationInfo->messageCount); |
| for (uint32_t i = 0; i < compilationInfo->messageCount; i++) { |
| auto& msg = compilationInfo->messages[i]; |
| messages[i] = |
| interop::GPUCompilationMessage::Create<GPUCompilationMessage>(ctx->env, msg); |
| } |
| |
| ctx->promise.Resolve(interop::GPUCompilationInfo::Create<GPUCompilationInfo>( |
| ctx->env, ctx->env, std::move(messages))); |
| }); |
| |
| return promise; |
| } |
| |
| std::string GPUShaderModule::getLabel(Napi::Env) { |
| return label_; |
| } |
| |
| void GPUShaderModule::setLabel(Napi::Env, std::string value) { |
| shader_.SetLabel(std::string_view(value)); |
| label_ = value; |
| } |
| |
| } // namespace wgpu::binding |