LibWeb/WebGL: Set prototypes of the WebGL objects

Libraries/LibWeb/WebGL/Types.h

@@ -12,5 +12,6 @@
 namespace Web::WebGL {
 
 using GLenum = unsigned int;
+using GLuint = unsigned int;
 
 }

Libraries/LibWeb/WebGL/WebGLBuffer.cpp

@@ -1,11 +1,13 @@
 /*
  * Copyright (c) 2024, Jelle Raaijmakers <jelle@ladybird.org>
  * Copyright (c) 2024, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
+ * Copyright (c) 2024, Luke Wilde <luke@ladybird.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
 #include <LibJS/Runtime/Realm.h>
+#include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Bindings/WebGLBufferPrototype.h>
 #include <LibWeb/WebGL/WebGLBuffer.h>
 
@@ -13,9 +15,9 @@ namespace Web::WebGL {
 
 GC_DEFINE_ALLOCATOR(WebGLBuffer);
 
-GC::Ptr<WebGLBuffer> WebGLBuffer::create(JS::Realm& realm, GLuint handle)
+GC::Ref<WebGLBuffer> WebGLBuffer::create(JS::Realm& realm, GLuint handle)
 {
-    return realm.heap().allocate<WebGLBuffer>(realm, handle);
+    return realm.create<WebGLBuffer>(realm, handle);
 }
 
 WebGLBuffer::WebGLBuffer(JS::Realm& realm, GLuint handle)
@@ -25,4 +27,10 @@ WebGLBuffer::WebGLBuffer(JS::Realm& realm, GLuint handle)
 
 WebGLBuffer::~WebGLBuffer() = default;
 
+void WebGLBuffer::initialize(JS::Realm& realm)
+{
+    Base::initialize(realm);
+    WEB_SET_PROTOTYPE_FOR_INTERFACE(WebGLBuffer);
+}
+
 }

Libraries/LibWeb/WebGL/WebGLBuffer.h

@@ -1,6 +1,7 @@
 /*
  * Copyright (c) 2024, Jelle Raaijmakers <jelle@ladybird.org>
  * Copyright (c) 2024, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
+ * Copyright (c) 2024, Luke Wilde <luke@ladybird.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
@@ -17,12 +18,14 @@ class WebGLBuffer final : public WebGLObject {
     GC_DECLARE_ALLOCATOR(WebGLBuffer);
 
 public:
-    static GC::Ptr<WebGLBuffer> create(JS::Realm& realm, GLuint handle);
+    static GC::Ref<WebGLBuffer> create(JS::Realm& realm, GLuint handle);
 
     virtual ~WebGLBuffer();
 
 protected:
     explicit WebGLBuffer(JS::Realm&, GLuint handle);
+
+    virtual void initialize(JS::Realm&) override;
 };
 
 }

Libraries/LibWeb/WebGL/WebGLFramebuffer.cpp

@@ -1,10 +1,12 @@
 /*
  * Copyright (c) 2024, Jelle Raaijmakers <jelle@ladybird.org>
+ * Copyright (c) 2024, Luke Wilde <luke@ladybird.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
 #include <LibJS/Runtime/Realm.h>
+#include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Bindings/WebGLFramebufferPrototype.h>
 #include <LibWeb/WebGL/WebGLFramebuffer.h>
 
@@ -12,9 +14,9 @@ namespace Web::WebGL {
 
 GC_DEFINE_ALLOCATOR(WebGLFramebuffer);
 
-GC::Ptr<WebGLFramebuffer> WebGLFramebuffer::create(JS::Realm& realm, GLuint handle)
+GC::Ref<WebGLFramebuffer> WebGLFramebuffer::create(JS::Realm& realm, GLuint handle)
 {
-    return realm.heap().allocate<WebGLFramebuffer>(realm, handle);
+    return realm.create<WebGLFramebuffer>(realm, handle);
 }
 
 WebGLFramebuffer::WebGLFramebuffer(JS::Realm& realm, GLuint handle)
@@ -24,4 +26,10 @@ WebGLFramebuffer::WebGLFramebuffer(JS::Realm& realm, GLuint handle)
 
 WebGLFramebuffer::~WebGLFramebuffer() = default;
 
+void WebGLFramebuffer::initialize(JS::Realm& realm)
+{
+    Base::initialize(realm);
+    WEB_SET_PROTOTYPE_FOR_INTERFACE(WebGLFramebuffer);
+}
+
 }

Libraries/LibWeb/WebGL/WebGLFramebuffer.h

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2024, Jelle Raaijmakers <jelle@ladybird.org>
+ * Copyright (c) 2024, Luke Wilde <luke@ladybird.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
@@ -15,12 +16,14 @@ class WebGLFramebuffer final : public WebGLObject {
     GC_DECLARE_ALLOCATOR(WebGLFramebuffer);
 
 public:
-    static GC::Ptr<WebGLFramebuffer> create(JS::Realm& realm, GLuint handle);
+    static GC::Ref<WebGLFramebuffer> create(JS::Realm& realm, GLuint handle);
 
     virtual ~WebGLFramebuffer();
 
 protected:
     explicit WebGLFramebuffer(JS::Realm&, GLuint handle);
+
+    virtual void initialize(JS::Realm&) override;
 };
 
 }

Libraries/LibWeb/WebGL/WebGLObject.cpp

@@ -1,10 +1,13 @@
 /*
  * Copyright (c) 2024, Jelle Raaijmakers <jelle@ladybird.org>
  * Copyright (c) 2024, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
+ * Copyright (c) 2024, Luke Wilde <luke@ladybird.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
+#include <LibWeb/Bindings/Intrinsics.h>
+#include <LibWeb/Bindings/WebGLObjectPrototype.h>
 #include <LibWeb/WebGL/WebGLObject.h>
 
 namespace Web::WebGL {
@@ -17,4 +20,10 @@ WebGLObject::WebGLObject(JS::Realm& realm, GLuint handle)
 
 WebGLObject::~WebGLObject() = default;
 
+void WebGLObject::initialize(JS::Realm& realm)
+{
+    Base::initialize(realm);
+    WEB_SET_PROTOTYPE_FOR_INTERFACE(WebGLObject);
+}
+
 }

Libraries/LibWeb/WebGL/WebGLObject.h

@@ -1,6 +1,7 @@
 /*
  * Copyright (c) 2024, Jelle Raaijmakers <jelle@ladybird.org>
  * Copyright (c) 2024, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
+ * Copyright (c) 2024, Luke Wilde <luke@ladybird.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
@@ -10,8 +11,6 @@
 #include <LibWeb/Bindings/PlatformObject.h>
 #include <LibWeb/WebGL/Types.h>
 
-typedef unsigned int GLuint;
-
 namespace Web::WebGL {
 
 class WebGLObject : public Bindings::PlatformObject {
@@ -28,6 +27,8 @@ public:
 protected:
     explicit WebGLObject(JS::Realm&, GLuint handle);
 
+    virtual void initialize(JS::Realm&) override;
+
     bool invalidated() const { return m_invalidated; }
 
 private:

Libraries/LibWeb/WebGL/WebGLProgram.cpp

@@ -1,11 +1,13 @@
 /*
  * Copyright (c) 2024, Jelle Raaijmakers <jelle@ladybird.org>
  * Copyright (c) 2024, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
+ * Copyright (c) 2024, Luke Wilde <luke@ladybird.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
 #include <LibJS/Runtime/Realm.h>
+#include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Bindings/WebGLProgramPrototype.h>
 #include <LibWeb/WebGL/WebGLProgram.h>
 
@@ -13,9 +15,9 @@ namespace Web::WebGL {
 
 GC_DEFINE_ALLOCATOR(WebGLProgram);
 
-GC::Ptr<WebGLProgram> WebGLProgram::create(JS::Realm& realm, GLuint handle)
+GC::Ref<WebGLProgram> WebGLProgram::create(JS::Realm& realm, GLuint handle)
 {
-    return realm.heap().allocate<WebGLProgram>(realm, handle);
+    return realm.create<WebGLProgram>(realm, handle);
 }
 
 WebGLProgram::WebGLProgram(JS::Realm& realm, GLuint handle)
@@ -25,4 +27,10 @@ WebGLProgram::WebGLProgram(JS::Realm& realm, GLuint handle)
 
 WebGLProgram::~WebGLProgram() = default;
 
+void WebGLProgram::initialize(JS::Realm& realm)
+{
+    Base::initialize(realm);
+    WEB_SET_PROTOTYPE_FOR_INTERFACE(WebGLProgram);
+}
+
 }

Libraries/LibWeb/WebGL/WebGLProgram.h

@@ -1,6 +1,7 @@
 /*
  * Copyright (c) 2024, Jelle Raaijmakers <jelle@ladybird.org>
  * Copyright (c) 2024, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
+ * Copyright (c) 2024, Luke Wilde <luke@ladybird.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
@@ -17,12 +18,14 @@ class WebGLProgram final : public WebGLObject {
     GC_DECLARE_ALLOCATOR(WebGLProgram);
 
 public:
-    static GC::Ptr<WebGLProgram> create(JS::Realm& realm, GLuint handle);
+    static GC::Ref<WebGLProgram> create(JS::Realm& realm, GLuint handle);
 
     virtual ~WebGLProgram();
 
 protected:
     explicit WebGLProgram(JS::Realm&, GLuint handle);
+
+    virtual void initialize(JS::Realm&) override;
 };
 
 }

Libraries/LibWeb/WebGL/WebGLRenderbuffer.cpp

@@ -1,10 +1,12 @@
 /*
  * Copyright (c) 2024, Jelle Raaijmakers <jelle@ladybird.org>
+ * Copyright (c) 2024, Luke Wilde <luke@ladybird.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
 #include <LibJS/Runtime/Realm.h>
+#include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Bindings/WebGLRenderbufferPrototype.h>
 #include <LibWeb/WebGL/WebGLRenderbuffer.h>
 
@@ -12,9 +14,9 @@ namespace Web::WebGL {
 
 GC_DEFINE_ALLOCATOR(WebGLRenderbuffer);
 
-GC::Ptr<WebGLRenderbuffer> WebGLRenderbuffer::create(JS::Realm& realm, GLuint handle)
+GC::Ref<WebGLRenderbuffer> WebGLRenderbuffer::create(JS::Realm& realm, GLuint handle)
 {
-    return realm.heap().allocate<WebGLRenderbuffer>(realm, handle);
+    return realm.create<WebGLRenderbuffer>(realm, handle);
 }
 
 WebGLRenderbuffer::WebGLRenderbuffer(JS::Realm& realm, GLuint handle)
@@ -24,4 +26,10 @@ WebGLRenderbuffer::WebGLRenderbuffer(JS::Realm& realm, GLuint handle)
 
 WebGLRenderbuffer::~WebGLRenderbuffer() = default;
 
+void WebGLRenderbuffer::initialize(JS::Realm& realm)
+{
+    Base::initialize(realm);
+    WEB_SET_PROTOTYPE_FOR_INTERFACE(WebGLRenderbuffer);
+}
+
 }

Libraries/LibWeb/WebGL/WebGLRenderbuffer.h

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2024, Jelle Raaijmakers <jelle@ladybird.org>
+ * Copyright (c) 2024, Luke Wilde <luke@ladybird.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
@@ -15,12 +16,14 @@ class WebGLRenderbuffer final : public WebGLObject {
     GC_DECLARE_ALLOCATOR(WebGLRenderbuffer);
 
 public:
-    static GC::Ptr<WebGLRenderbuffer> create(JS::Realm& realm, GLuint handle);
+    static GC::Ref<WebGLRenderbuffer> create(JS::Realm& realm, GLuint handle);
 
     virtual ~WebGLRenderbuffer();
 
 protected:
     explicit WebGLRenderbuffer(JS::Realm&, GLuint handle);
+
+    virtual void initialize(JS::Realm&) override;
 };
 
 }

Libraries/LibWeb/WebGL/WebGLShader.cpp

@@ -1,11 +1,13 @@
 /*
  * Copyright (c) 2024, Jelle Raaijmakers <jelle@ladybird.org>
  * Copyright (c) 2024, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
+ * Copyright (c) 2024, Luke Wilde <luke@ladybird.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
 #include <LibJS/Runtime/Realm.h>
+#include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Bindings/WebGLShaderPrototype.h>
 #include <LibWeb/WebGL/WebGLShader.h>
 
@@ -13,9 +15,9 @@ namespace Web::WebGL {
 
 GC_DEFINE_ALLOCATOR(WebGLShader);
 
-GC::Ptr<WebGLShader> WebGLShader::create(JS::Realm& realm, GLuint handle)
+GC::Ref<WebGLShader> WebGLShader::create(JS::Realm& realm, GLuint handle)
 {
-    return realm.heap().allocate<WebGLShader>(realm, handle);
+    return realm.create<WebGLShader>(realm, handle);
 }
 
 WebGLShader::WebGLShader(JS::Realm& realm, GLuint handle)
@@ -25,4 +27,10 @@ WebGLShader::WebGLShader(JS::Realm& realm, GLuint handle)
 
 WebGLShader::~WebGLShader() = default;
 
+void WebGLShader::initialize(JS::Realm& realm)
+{
+    Base::initialize(realm);
+    WEB_SET_PROTOTYPE_FOR_INTERFACE(WebGLShader);
+}
+
 }

Libraries/LibWeb/WebGL/WebGLShader.h

@@ -1,6 +1,7 @@
 /*
  * Copyright (c) 2024, Jelle Raaijmakers <jelle@ladybird.org>
  * Copyright (c) 2024, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
+ * Copyright (c) 2024, Luke Wilde <luke@ladybird.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
@@ -17,12 +18,14 @@ class WebGLShader final : public WebGLObject {
     GC_DECLARE_ALLOCATOR(WebGLShader);
 
 public:
-    static GC::Ptr<WebGLShader> create(JS::Realm& realm, GLuint handle);
+    static GC::Ref<WebGLShader> create(JS::Realm& realm, GLuint handle);
 
     virtual ~WebGLShader();
 
 protected:
     explicit WebGLShader(JS::Realm&, GLuint handle);
+
+    virtual void initialize(JS::Realm&) override;
 };
 
 }

Libraries/LibWeb/WebGL/WebGLTexture.cpp

@@ -1,11 +1,13 @@
 /*
  * Copyright (c) 2024, Jelle Raaijmakers <jelle@ladybird.org>
  * Copyright (c) 2024, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
+ * Copyright (c) 2024, Luke Wilde <luke@ladybird.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
 #include <LibJS/Runtime/Realm.h>
+#include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Bindings/WebGLTexturePrototype.h>
 #include <LibWeb/WebGL/WebGLTexture.h>
 
@@ -13,9 +15,9 @@ namespace Web::WebGL {
 
 GC_DEFINE_ALLOCATOR(WebGLTexture);
 
-GC::Ptr<WebGLTexture> WebGLTexture::create(JS::Realm& realm, GLuint handle)
+GC::Ref<WebGLTexture> WebGLTexture::create(JS::Realm& realm, GLuint handle)
 {
-    return realm.heap().allocate<WebGLTexture>(realm, handle);
+    return realm.create<WebGLTexture>(realm, handle);
 }
 
 WebGLTexture::WebGLTexture(JS::Realm& realm, GLuint handle)
@@ -25,4 +27,10 @@ WebGLTexture::WebGLTexture(JS::Realm& realm, GLuint handle)
 
 WebGLTexture::~WebGLTexture() = default;
 
+void WebGLTexture::initialize(JS::Realm& realm)
+{
+    Base::initialize(realm);
+    WEB_SET_PROTOTYPE_FOR_INTERFACE(WebGLTexture);
+}
+
 }

Libraries/LibWeb/WebGL/WebGLTexture.h

@@ -1,6 +1,7 @@
 /*
  * Copyright (c) 2024, Jelle Raaijmakers <jelle@ladybird.org>
  * Copyright (c) 2024, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
+ * Copyright (c) 2024, Luke Wilde <luke@ladybird.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
@@ -17,12 +18,14 @@ class WebGLTexture final : public WebGLObject {
     GC_DECLARE_ALLOCATOR(WebGLTexture);
 
 public:
-    static GC::Ptr<WebGLTexture> create(JS::Realm& realm, GLuint handle);
+    static GC::Ref<WebGLTexture> create(JS::Realm& realm, GLuint handle);
 
     virtual ~WebGLTexture();
 
 protected:
     explicit WebGLTexture(JS::Realm&, GLuint handle);
+
+    virtual void initialize(JS::Realm&) override;
 };
 
 }

Libraries/LibWeb/WebGL/WebGLUniformLocation.cpp

@@ -1,11 +1,13 @@
 /*
  * Copyright (c) 2024, Jelle Raaijmakers <jelle@ladybird.org>
  * Copyright (c) 2024, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
+ * Copyright (c) 2024, Luke Wilde <luke@ladybird.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
 #include <LibJS/Runtime/Realm.h>
+#include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Bindings/WebGLUniformLocationPrototype.h>
 #include <LibWeb/WebGL/WebGLUniformLocation.h>
 
@@ -13,16 +15,23 @@ namespace Web::WebGL {
 
 GC_DEFINE_ALLOCATOR(WebGLUniformLocation);
 
-GC::Ptr<WebGLUniformLocation> WebGLUniformLocation::create(JS::Realm& realm, GLuint handle)
+GC::Ref<WebGLUniformLocation> WebGLUniformLocation::create(JS::Realm& realm, GLuint handle)
 {
-    return realm.heap().allocate<WebGLUniformLocation>(realm, handle);
+    return realm.create<WebGLUniformLocation>(realm, handle);
 }
 
 WebGLUniformLocation::WebGLUniformLocation(JS::Realm& realm, GLuint handle)
-    : WebGLObject(realm, handle)
+    : Bindings::PlatformObject(realm)
+    , m_handle(handle)
 {
 }
 
 WebGLUniformLocation::~WebGLUniformLocation() = default;
 
+void WebGLUniformLocation::initialize(JS::Realm& realm)
+{
+    Base::initialize(realm);
+    WEB_SET_PROTOTYPE_FOR_INTERFACE(WebGLUniformLocation);
+}
+
 }

Libraries/LibWeb/WebGL/WebGLUniformLocation.h

@@ -7,21 +7,28 @@
 
 #pragma once
 
-#include <LibWeb/WebGL/WebGLObject.h>
+#include <LibWeb/Bindings/PlatformObject.h>
+#include <LibWeb/WebGL/Types.h>
 
 namespace Web::WebGL {
 
-class WebGLUniformLocation final : public WebGLObject {
-    WEB_PLATFORM_OBJECT(WebGLUniformLocation, WebGLObject);
+class WebGLUniformLocation final : public Bindings::PlatformObject {
+    WEB_PLATFORM_OBJECT(WebGLUniformLocation, Bindings::PlatformObject);
     GC_DECLARE_ALLOCATOR(WebGLUniformLocation);
 
 public:
-    static GC::Ptr<WebGLUniformLocation> create(JS::Realm& realm, GLuint handle);
+    static GC::Ref<WebGLUniformLocation> create(JS::Realm& realm, GLuint handle);
 
     virtual ~WebGLUniformLocation();
 
+    GLuint handle() const { return m_handle; }
+
 protected:
     explicit WebGLUniformLocation(JS::Realm&, GLuint handle);
+
+    virtual void initialize(JS::Realm&) override;
+
+    GLuint m_handle { 0 };
 };
 
 }