97abc707c7
Represent BufferSource and ArrayBufferView as ordinary IDL typedefs over their underlying union types, instead of special casing in the IDL generator. This allows the union conversion/return machinery handle these types consistently with other typedefs, which removes buffer specific paths from the IDL generator. This necessitates changing the WebIDL::BufferSource and WebIDL::ArrayBufferView classes as views over these variants. This replaces the old GC backed BufferableObject wrapper structure and provide convenience helpers to determine things such as the byte length, byte offset, backing buffer, and typed-array APIs.
189 lines
9 KiB
C++
189 lines
9 KiB
C++
/*
|
|
* Copyright (c) 2024-2025, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <LibGfx/BitmapExport.h>
|
|
#include <LibJS/Runtime/DataView.h>
|
|
#include <LibJS/Runtime/TypedArray.h>
|
|
#include <LibWeb/Bindings/PlatformObject.h>
|
|
#include <LibWeb/Forward.h>
|
|
#include <LibWeb/WebGL/Types.h>
|
|
#include <LibWeb/WebIDL/Buffers.h>
|
|
#include <LibWeb/WebIDL/Types.h>
|
|
|
|
#define SET_ERROR_VALUE_IF_ERROR(expression, error_value) \
|
|
({ \
|
|
auto maybe_error = expression; \
|
|
if (maybe_error.is_error()) [[unlikely]] { \
|
|
set_error(error_value); \
|
|
return; \
|
|
} \
|
|
maybe_error.release_value(); \
|
|
})
|
|
|
|
namespace Web::WebGL {
|
|
|
|
static constexpr int COMPRESSED_TEXTURE_FORMATS = 0x86A3;
|
|
static constexpr int UNPACK_FLIP_Y_WEBGL = 0x9240;
|
|
static constexpr int UNPACK_PREMULTIPLY_ALPHA_WEBGL = 0x9241;
|
|
static constexpr int UNPACK_COLORSPACE_CONVERSION_WEBGL = 0x9243;
|
|
static constexpr int BROWSER_DEFAULT_WEBGL = 0x9244;
|
|
static constexpr int MAX_CLIENT_WAIT_TIMEOUT_WEBGL = 0x9247;
|
|
|
|
// NOTE: This is the Variant created by the IDL wrapper generator, and needs to be updated accordingly.
|
|
using TexImageSource = Variant<GC::Ref<HTML::ImageBitmap>, GC::Ref<HTML::ImageData>, GC::Ref<HTML::HTMLImageElement>, GC::Ref<HTML::HTMLCanvasElement>, GC::Ref<HTML::OffscreenCanvas>, GC::Ref<HTML::HTMLVideoElement>>;
|
|
|
|
class WebGLRenderingContextBase : public Bindings::PlatformObject {
|
|
WEB_NON_IDL_PLATFORM_OBJECT(WebGLRenderingContextBase, Bindings::PlatformObject);
|
|
|
|
public:
|
|
using Float32List = Variant<GC::Ref<JS::Float32Array>, Vector<float>>;
|
|
using Int32List = Variant<GC::Ref<JS::Int32Array>, Vector<WebIDL::Long>>;
|
|
using Uint32List = Variant<GC::Ref<JS::Uint32Array>, Vector<WebIDL::UnsignedLong>>;
|
|
|
|
virtual OpenGLContext& context() = 0;
|
|
|
|
bool is_context_lost() const;
|
|
|
|
bool xr_compatible() const { return m_xr_compatible; }
|
|
void set_xr_compatible(bool xr_compatible) { m_xr_compatible = xr_compatible; }
|
|
|
|
// https://immersive-web.github.io/webxr/#dom-webglrenderingcontextbase-makexrcompatible
|
|
GC::Ref<WebIDL::Promise> make_xr_compatible();
|
|
|
|
Optional<Vector<String>> get_supported_extensions();
|
|
JS::Object* get_extension(String const& name);
|
|
|
|
void enable_compressed_texture_format(WebIDL::UnsignedLong format);
|
|
|
|
protected:
|
|
WebGLRenderingContextBase(JS::Realm&);
|
|
|
|
virtual void visit_edges(Cell::Visitor&) override;
|
|
|
|
// FIXME: Make this and any another instance of extension names a FlyString, similarly to HTML::TagNames
|
|
bool extension_enabled(StringView extension) const;
|
|
ReadonlySpan<WebIDL::UnsignedLong> enabled_compressed_texture_formats() const;
|
|
|
|
template<typename T>
|
|
static ErrorOr<Span<T>> get_offset_span(Span<T> src_span, WebIDL::UnsignedLongLong src_offset, WebIDL::UnsignedLong src_length_override = 0)
|
|
{
|
|
Checked<WebIDL::UnsignedLongLong> length = src_offset;
|
|
length += src_length_override;
|
|
if (length.has_overflow() || length.value_unchecked() > src_span.size()) [[unlikely]]
|
|
return Error::from_errno(EINVAL);
|
|
|
|
if (src_length_override == 0)
|
|
return src_span.slice(src_offset, src_span.size() - src_offset);
|
|
|
|
return src_span.slice(src_offset, src_length_override);
|
|
}
|
|
|
|
template<typename T>
|
|
static ErrorOr<Span<T>> get_offset_span(WebIDL::BufferSource src_data, WebIDL::UnsignedLongLong src_offset, WebIDL::UnsignedLong src_length_override = 0)
|
|
{
|
|
auto buffer_size = src_data.byte_length();
|
|
if (buffer_size % sizeof(T) != 0) [[unlikely]]
|
|
return Error::from_errno(EINVAL);
|
|
|
|
return src_data.buffer_source().visit(
|
|
[&](GC::Ref<JS::ArrayBuffer> array_buffer) -> ErrorOr<Span<T>> {
|
|
return TRY(get_offset_span(array_buffer->span(), src_offset, src_length_override)).template reinterpret<T>();
|
|
},
|
|
[&](GC::Ref<JS::DataView> data_view) -> ErrorOr<Span<T>> {
|
|
return TRY(get_offset_span(data_view->viewed_array_buffer()->span(), src_offset, src_length_override)).template reinterpret<T>();
|
|
},
|
|
[&](auto const& typed_array) -> ErrorOr<Span<T>> {
|
|
// NOTE: src_offset is the number of elements to offset by, not the number of bytes.
|
|
return TRY(get_offset_span(typed_array->data(), src_offset, src_length_override)).template reinterpret<T>();
|
|
});
|
|
}
|
|
|
|
static ErrorOr<Span<float>> span_from_float32_list(Float32List& float32_list, WebIDL::UnsignedLongLong src_offset, WebIDL::UnsignedLong src_length_override = 0)
|
|
{
|
|
if (float32_list.has<Vector<float>>()) {
|
|
auto& vector = float32_list.get<Vector<float>>();
|
|
return get_offset_span(vector.span(), src_offset, src_length_override);
|
|
}
|
|
auto& buffer = float32_list.get<GC::Ref<JS::Float32Array>>();
|
|
return get_offset_span(buffer->data(), src_offset, src_length_override);
|
|
}
|
|
|
|
static ErrorOr<Span<int>> span_from_int32_list(Int32List& int32_list, WebIDL::UnsignedLongLong src_offset, WebIDL::UnsignedLong src_length_override = 0)
|
|
{
|
|
if (int32_list.has<Vector<int>>()) {
|
|
auto& vector = int32_list.get<Vector<int>>();
|
|
return get_offset_span(vector.span(), src_offset, src_length_override);
|
|
}
|
|
auto& buffer = int32_list.get<GC::Ref<JS::Int32Array>>();
|
|
return get_offset_span(buffer->data(), src_offset, src_length_override);
|
|
}
|
|
|
|
static ErrorOr<Span<u32>> span_from_uint32_list(Uint32List& uint32_list, WebIDL::UnsignedLongLong src_offset, WebIDL::UnsignedLong src_length_override = 0)
|
|
{
|
|
if (uint32_list.has<Vector<u32>>()) {
|
|
auto& vector = uint32_list.get<Vector<u32>>();
|
|
return get_offset_span(vector.span(), src_offset, src_length_override);
|
|
}
|
|
auto& buffer = uint32_list.get<GC::Ref<JS::Uint32Array>>();
|
|
return get_offset_span(buffer->data(), src_offset, src_length_override);
|
|
}
|
|
|
|
Optional<Gfx::BitmapExportResult> read_and_pixel_convert_texture_image_source(TexImageSource const& source, WebIDL::UnsignedLong format, WebIDL::UnsignedLong type, Optional<int> destination_width = OptionalNone {}, Optional<int> destination_height = OptionalNone {});
|
|
|
|
static Vector<GLchar> null_terminated_string(StringView string)
|
|
{
|
|
Vector<GLchar> result;
|
|
result.ensure_capacity(string.length() + 1);
|
|
for (auto c : string.bytes())
|
|
result.append(c);
|
|
result.append('\0');
|
|
return result;
|
|
}
|
|
|
|
GLenum get_error_value();
|
|
void set_error(GLenum error);
|
|
|
|
// UNPACK_FLIP_Y_WEBGL of type boolean
|
|
// If set, then during any subsequent calls to texImage2D or texSubImage2D, the source data is flipped along
|
|
// the vertical axis, so that conceptually the last row is the first one transferred. The initial value is false.
|
|
// Any non-zero value is interpreted as true.
|
|
bool m_unpack_flip_y { false };
|
|
|
|
// UNPACK_PREMULTIPLY_ALPHA_WEBGL of type boolean
|
|
// If set, then during any subsequent calls to texImage2D or texSubImage2D, the alpha channel of the source data,
|
|
// if present, is multiplied into the color channels during the data transfer. The initial value is false.
|
|
// Any non-zero value is interpreted as true.
|
|
bool m_unpack_premultiply_alpha { false };
|
|
|
|
// UNPACK_COLORSPACE_CONVERSION_WEBGL of type unsigned long
|
|
// If set to BROWSER_DEFAULT_WEBGL, then the browser's default colorspace conversion (e.g. converting a display-p3
|
|
// image to srgb) is applied during subsequent texture data upload calls (e.g. texImage2D and texSubImage2D) that
|
|
// take an argument of TexImageSource. The precise conversions may be specific to both the browser and file type.
|
|
// If set to NONE, no colorspace conversion is applied, other than conversion to RGBA. (For example, a rec709 YUV
|
|
// video is still converted to rec709 RGB data, but not then converted to e.g. srgb RGB data) The initial value is
|
|
// BROWSER_DEFAULT_WEBGL.
|
|
GLenum m_unpack_colorspace_conversion { BROWSER_DEFAULT_WEBGL };
|
|
|
|
private:
|
|
GLenum m_error { 0 };
|
|
|
|
// https://registry.khronos.org/webgl/specs/latest/2.0/#webgl-context-lost-flag
|
|
// Each WebGLRenderingContext and WebGL2RenderingContext has a webgl context lost flag, which is initially unset.
|
|
bool m_context_lost { false };
|
|
|
|
// https://immersive-web.github.io/webxr/#xr-compatible
|
|
bool m_xr_compatible { false };
|
|
|
|
Vector<WebIDL::UnsignedLong> m_enabled_compressed_texture_formats;
|
|
|
|
// Extensions
|
|
// "Multiple calls to getExtension with the same extension string, taking into account case-insensitive comparison, must return the same object as long as the extension is enabled."
|
|
HashMap<String, GC::Ref<JS::Object>, AK::ASCIICaseInsensitiveStringTraits> m_enabled_extensions;
|
|
};
|
|
|
|
}
|