GenerateWebGLRenderingContext.cpp 40 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030
  1. /*
  2. * Copyright (c) 2024, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
  3. * Copyright (c) 2024, Luke Wilde <luke@ladybird.org>
  4. *
  5. * SPDX-License-Identifier: BSD-2-Clause
  6. */
  7. #include "BindingsGenerator/IDLGenerators.h"
  8. #include <AK/LexicalPath.h>
  9. #include <AK/SourceGenerator.h>
  10. #include <AK/StringBuilder.h>
  11. #include <LibCore/ArgsParser.h>
  12. #include <LibCore/File.h>
  13. #include <LibIDL/IDLParser.h>
  14. #include <LibMain/Main.h>
  15. static bool is_webgl_object_type(StringView type_name)
  16. {
  17. return type_name == "WebGLBuffer"sv
  18. || type_name == "WebGLFramebuffer"sv
  19. || type_name == "WebGLProgram"sv
  20. || type_name == "WebGLRenderbuffer"sv
  21. || type_name == "WebGLSampler"sv
  22. || type_name == "WebGLShader"sv
  23. || type_name == "WebGLTexture"sv
  24. || type_name == "WebGLUniformLocation"sv
  25. || type_name == "WebGLVertexArrayObject"sv;
  26. }
  27. static bool gl_function_modifies_framebuffer(StringView function_name)
  28. {
  29. return function_name == "clearColor"sv || function_name == "drawArrays"sv || function_name == "drawElements"sv;
  30. }
  31. static ByteString to_cpp_type(const IDL::Type& type, const IDL::Interface& interface)
  32. {
  33. if (type.name() == "undefined"sv)
  34. return "void"sv;
  35. if (type.name() == "object"sv) {
  36. if (type.is_nullable())
  37. return "JS::Object*"sv;
  38. return "JS::Object&"sv;
  39. }
  40. if (type.name() == "DOMString"sv) {
  41. if (type.is_nullable())
  42. return "Optional<String>"sv;
  43. return "String"sv;
  44. }
  45. auto cpp_type = idl_type_name_to_cpp_type(type, interface);
  46. return cpp_type.name;
  47. }
  48. static ByteString idl_to_gl_function_name(StringView function_name)
  49. {
  50. StringBuilder gl_function_name_builder;
  51. gl_function_name_builder.append("gl"sv);
  52. for (size_t i = 0; i < function_name.length(); ++i) {
  53. if (i == 0) {
  54. gl_function_name_builder.append(to_ascii_uppercase(function_name[i]));
  55. } else {
  56. gl_function_name_builder.append(function_name[i]);
  57. }
  58. }
  59. if (function_name == "clearDepth"sv || function_name == "depthRange"sv) {
  60. gl_function_name_builder.append("f"sv);
  61. }
  62. return gl_function_name_builder.to_byte_string();
  63. }
  64. struct NameAndType {
  65. StringView name;
  66. struct {
  67. StringView type;
  68. int element_count { 0 };
  69. } return_type;
  70. Optional<int> webgl_version { OptionalNone {} };
  71. };
  72. static void generate_get_parameter(SourceGenerator& generator, int webgl_version)
  73. {
  74. Vector<NameAndType> const name_to_type = {
  75. { "ACTIVE_TEXTURE"sv, { "GLenum"sv } },
  76. { "ALIASED_LINE_WIDTH_RANGE"sv, { "Float32Array"sv, 2 } },
  77. { "ALIASED_POINT_SIZE_RANGE"sv, { "Float32Array"sv, 2 } },
  78. { "ALPHA_BITS"sv, { "GLint"sv } },
  79. { "ARRAY_BUFFER_BINDING"sv, { "WebGLBuffer"sv } },
  80. { "BLEND"sv, { "GLboolean"sv } },
  81. { "BLEND_COLOR"sv, { "Float32Array"sv, 4 } },
  82. { "BLEND_DST_ALPHA"sv, { "GLenum"sv } },
  83. { "BLEND_DST_RGB"sv, { "GLenum"sv } },
  84. { "BLEND_EQUATION_ALPHA"sv, { "GLenum"sv } },
  85. { "BLEND_EQUATION_RGB"sv, { "GLenum"sv } },
  86. { "BLEND_SRC_ALPHA"sv, { "GLenum"sv } },
  87. { "BLEND_SRC_RGB"sv, { "GLenum"sv } },
  88. { "BLUE_BITS"sv, { "GLint"sv } },
  89. { "COLOR_CLEAR_VALUE"sv, { "Float32Array"sv, 4 } },
  90. // FIXME: { "COLOR_WRITEMASK"sv, { "sequence<GLboolean>"sv, 4 } },
  91. // FIXME: { "COMPRESSED_TEXTURE_FORMATS"sv, { "Uint32Array"sv } },
  92. { "CULL_FACE"sv, { "GLboolean"sv } },
  93. { "CULL_FACE_MODE"sv, { "GLenum"sv } },
  94. { "CURRENT_PROGRAM"sv, { "WebGLProgram"sv } },
  95. { "DEPTH_BITS"sv, { "GLint"sv } },
  96. { "DEPTH_CLEAR_VALUE"sv, { "GLfloat"sv } },
  97. { "DEPTH_FUNC"sv, { "GLenum"sv } },
  98. { "DEPTH_RANGE"sv, { "Float32Array"sv, 2 } },
  99. { "DEPTH_TEST"sv, { "GLboolean"sv } },
  100. { "DEPTH_WRITEMASK"sv, { "GLboolean"sv } },
  101. { "DITHER"sv, { "GLboolean"sv } },
  102. { "ELEMENT_ARRAY_BUFFER_BINDING"sv, { "WebGLBuffer"sv } },
  103. { "FRAMEBUFFER_BINDING"sv, { "WebGLFramebuffer"sv } },
  104. { "FRONT_FACE"sv, { "GLenum"sv } },
  105. { "GENERATE_MIPMAP_HINT"sv, { "GLenum"sv } },
  106. { "GREEN_BITS"sv, { "GLint"sv } },
  107. { "IMPLEMENTATION_COLOR_READ_FORMAT"sv, { "GLenum"sv } },
  108. { "IMPLEMENTATION_COLOR_READ_TYPE"sv, { "GLenum"sv } },
  109. { "LINE_WIDTH"sv, { "GLfloat"sv } },
  110. { "MAX_COMBINED_TEXTURE_IMAGE_UNITS"sv, { "GLint"sv } },
  111. { "MAX_CUBE_MAP_TEXTURE_SIZE"sv, { "GLint"sv } },
  112. { "MAX_FRAGMENT_UNIFORM_VECTORS"sv, { "GLint"sv } },
  113. { "MAX_RENDERBUFFER_SIZE"sv, { "GLint"sv } },
  114. { "MAX_TEXTURE_IMAGE_UNITS"sv, { "GLint"sv } },
  115. { "MAX_TEXTURE_SIZE"sv, { "GLint"sv } },
  116. { "MAX_VARYING_VECTORS"sv, { "GLint"sv } },
  117. { "MAX_VERTEX_ATTRIBS"sv, { "GLint"sv } },
  118. { "MAX_VERTEX_TEXTURE_IMAGE_UNITS"sv, { "GLint"sv } },
  119. { "MAX_VERTEX_UNIFORM_VECTORS"sv, { "GLint"sv } },
  120. { "MAX_VIEWPORT_DIMS"sv, { "Int32Array"sv, 2 } },
  121. { "PACK_ALIGNMENT"sv, { "GLint"sv } },
  122. { "POLYGON_OFFSET_FACTOR"sv, { "GLfloat"sv } },
  123. { "POLYGON_OFFSET_FILL"sv, { "GLboolean"sv } },
  124. { "POLYGON_OFFSET_UNITS"sv, { "GLfloat"sv } },
  125. { "RED_BITS"sv, { "GLint"sv } },
  126. { "RENDERBUFFER_BINDING"sv, { "WebGLRenderbuffer"sv } },
  127. { "RENDERER"sv, { "DOMString"sv } },
  128. { "SAMPLE_ALPHA_TO_COVERAGE"sv, { "GLboolean"sv } },
  129. { "SAMPLE_BUFFERS"sv, { "GLint"sv } },
  130. { "SAMPLE_COVERAGE"sv, { "GLboolean"sv } },
  131. { "SAMPLE_COVERAGE_INVERT"sv, { "GLboolean"sv } },
  132. { "SAMPLE_COVERAGE_VALUE"sv, { "GLfloat"sv } },
  133. { "SAMPLES"sv, { "GLint"sv } },
  134. { "SCISSOR_BOX"sv, { "Int32Array"sv, 4 } },
  135. { "SCISSOR_TEST"sv, { "GLboolean"sv } },
  136. { "SHADING_LANGUAGE_VERSION"sv, { "DOMString"sv } },
  137. { "STENCIL_BACK_FAIL"sv, { "GLenum"sv } },
  138. { "STENCIL_BACK_FUNC"sv, { "GLenum"sv } },
  139. { "STENCIL_BACK_PASS_DEPTH_FAIL"sv, { "GLenum"sv } },
  140. { "STENCIL_BACK_PASS_DEPTH_PASS"sv, { "GLenum"sv } },
  141. { "STENCIL_BACK_REF"sv, { "GLint"sv } },
  142. { "STENCIL_BACK_VALUE_MASK"sv, { "GLuint"sv } },
  143. { "STENCIL_BACK_WRITEMASK"sv, { "GLuint"sv } },
  144. { "STENCIL_BITS"sv, { "GLint"sv } },
  145. { "STENCIL_CLEAR_VALUE"sv, { "GLint"sv } },
  146. { "STENCIL_FAIL"sv, { "GLenum"sv } },
  147. { "STENCIL_FUNC"sv, { "GLenum"sv } },
  148. { "STENCIL_PASS_DEPTH_FAIL"sv, { "GLenum"sv } },
  149. { "STENCIL_PASS_DEPTH_PASS"sv, { "GLenum"sv } },
  150. { "STENCIL_REF"sv, { "GLint"sv } },
  151. { "STENCIL_TEST"sv, { "GLboolean"sv } },
  152. { "STENCIL_VALUE_MASK"sv, { "GLuint"sv } },
  153. { "STENCIL_WRITEMASK"sv, { "GLuint"sv } },
  154. { "SUBPIXEL_BITS"sv, { "GLint"sv } },
  155. { "TEXTURE_BINDING_2D"sv, { "WebGLTexture"sv } },
  156. { "TEXTURE_BINDING_CUBE_MAP"sv, { "WebGLTexture"sv } },
  157. { "UNPACK_ALIGNMENT"sv, { "GLint"sv } },
  158. // FIXME: { "UNPACK_COLORSPACE_CONVERSION_WEBGL"sv, { "GLenum"sv } },
  159. // FIXME: { "UNPACK_FLIP_Y_WEBGL"sv, { "GLboolean"sv } },
  160. // FIXME: { "UNPACK_PREMULTIPLY_ALPHA_WEBGL"sv, { "GLboolean"sv } },
  161. { "VENDOR"sv, { "DOMString"sv } },
  162. { "VERSION"sv, { "DOMString"sv } },
  163. { "VIEWPORT"sv, { "Int32Array"sv, 4 } },
  164. { "MAX_SAMPLES"sv, { "GLint"sv }, 2 },
  165. };
  166. auto is_primitive_type = [](StringView type) {
  167. return type == "GLboolean"sv || type == "GLint"sv || type == "GLfloat"sv || type == "GLenum"sv || type == "GLuint"sv;
  168. };
  169. generator.append(" switch (pname) {");
  170. for (auto const& name_and_type : name_to_type) {
  171. if (name_and_type.webgl_version.has_value() && name_and_type.webgl_version.value() != webgl_version)
  172. continue;
  173. auto const& parameter_name = name_and_type.name;
  174. auto const& type_name = name_and_type.return_type.type;
  175. StringBuilder string_builder;
  176. SourceGenerator impl_generator { string_builder };
  177. impl_generator.set("parameter_name", parameter_name);
  178. impl_generator.set("type_name", type_name);
  179. impl_generator.append(R"~~~(
  180. case GL_@parameter_name@: {)~~~");
  181. if (is_primitive_type(type_name)) {
  182. impl_generator.append(R"~~~(
  183. GLint result;
  184. glGetIntegerv(GL_@parameter_name@, &result);
  185. return JS::Value(result);
  186. )~~~");
  187. } else if (type_name == "DOMString"sv) {
  188. impl_generator.append(R"~~~(
  189. auto result = reinterpret_cast<const char*>(glGetString(GL_@parameter_name@));
  190. return JS::PrimitiveString::create(m_realm->vm(), ByteString { result });)~~~");
  191. } else if (type_name == "Float32Array"sv || type_name == "Int32Array"sv) {
  192. auto element_count = name_and_type.return_type.element_count;
  193. impl_generator.set("element_count", MUST(String::formatted("{}", element_count)));
  194. if (type_name == "Int32Array"sv) {
  195. impl_generator.set("gl_function_name", "glGetIntegerv"sv);
  196. impl_generator.set("element_type", "GLint"sv);
  197. } else if (type_name == "Float32Array"sv) {
  198. impl_generator.set("gl_function_name", "glGetFloatv"sv);
  199. impl_generator.set("element_type", "GLfloat"sv);
  200. } else {
  201. VERIFY_NOT_REACHED();
  202. }
  203. impl_generator.append(R"~~~(
  204. Array<@element_type@, @element_count@> result;
  205. @gl_function_name@(GL_@parameter_name@, result.data());
  206. auto byte_buffer = MUST(ByteBuffer::copy(result.data(), @element_count@ * sizeof(@element_type@)));
  207. auto array_buffer = JS::ArrayBuffer::create(m_realm, move(byte_buffer));
  208. return JS::@type_name@::create(m_realm, @element_count@, array_buffer);
  209. )~~~");
  210. } else if (type_name == "WebGLProgram"sv || type_name == "WebGLBuffer"sv || type_name == "WebGLTexture"sv || type_name == "WebGLFramebuffer"sv || type_name == "WebGLRenderbuffer"sv) {
  211. impl_generator.append(R"~~~(
  212. GLint result;
  213. glGetIntegerv(GL_@parameter_name@, &result);
  214. if (!result)
  215. return JS::js_null();
  216. return @type_name@::create(m_realm, result);
  217. )~~~");
  218. } else {
  219. VERIFY_NOT_REACHED();
  220. }
  221. impl_generator.append(" }");
  222. generator.append(string_builder.string_view());
  223. }
  224. generator.appendln(R"~~~(
  225. default:
  226. dbgln("Unknown WebGL parameter name: {:x}", pname);
  227. set_error(GL_INVALID_ENUM);
  228. return JS::js_null();
  229. })~~~");
  230. }
  231. static void generate_get_buffer_parameter(SourceGenerator& generator)
  232. {
  233. Vector<NameAndType> const name_to_type = {
  234. { "BUFFER_SIZE"sv, { "GLint"sv } },
  235. { "BUFFER_USAGE"sv, { "GLenum"sv } },
  236. };
  237. generator.append(" switch (pname) {");
  238. for (auto const& name_and_type : name_to_type) {
  239. auto const& parameter_name = name_and_type.name;
  240. auto const& type_name = name_and_type.return_type.type;
  241. StringBuilder string_builder;
  242. SourceGenerator impl_generator { string_builder };
  243. impl_generator.set("parameter_name", parameter_name);
  244. impl_generator.set("type_name", type_name);
  245. impl_generator.append(R"~~~(
  246. case GL_@parameter_name@: {
  247. GLint result;
  248. glGetBufferParameteriv(target, GL_@parameter_name@, &result);
  249. return JS::Value(result);
  250. }
  251. )~~~");
  252. generator.append(string_builder.string_view());
  253. }
  254. generator.appendln(R"~~~(
  255. default:
  256. TODO();
  257. })~~~");
  258. }
  259. ErrorOr<int> serenity_main(Main::Arguments arguments)
  260. {
  261. StringView generated_header_path;
  262. StringView generated_implementation_path;
  263. Vector<ByteString> base_paths;
  264. StringView webgl_context_idl_path;
  265. Core::ArgsParser args_parser;
  266. args_parser.add_option(webgl_context_idl_path, "Path to the WebGLRenderingContext idl file", "webgl-idl-path", 'i', "webgl-idl-path");
  267. args_parser.add_option(Core::ArgsParser::Option {
  268. .argument_mode = Core::ArgsParser::OptionArgumentMode::Required,
  269. .help_string = "Path to root of IDL file tree(s)",
  270. .long_name = "base-path",
  271. .short_name = 'b',
  272. .value_name = "base-path",
  273. .accept_value = [&](StringView s) {
  274. base_paths.append(s);
  275. return true;
  276. },
  277. });
  278. args_parser.add_option(generated_header_path, "Path to the header file to generate", "generated-header-path", 'h', "generated-header-path");
  279. args_parser.add_option(generated_implementation_path, "Path to the implementation file to generate", "generated-implementation-path", 'c', "generated-implementation-path");
  280. args_parser.parse(arguments);
  281. auto generated_header_file = TRY(Core::File::open(generated_header_path, Core::File::OpenMode::Write));
  282. auto generated_implementation_file = TRY(Core::File::open(generated_implementation_path, Core::File::OpenMode::Write));
  283. auto idl_file = MUST(Core::File::open(webgl_context_idl_path, Core::File::OpenMode::Read));
  284. auto webgl_context_idl_file_content = MUST(idl_file->read_until_eof());
  285. Vector<ByteString> import_base_paths;
  286. for (auto const& base_path : base_paths) {
  287. VERIFY(!base_path.is_empty());
  288. import_base_paths.append(base_path);
  289. }
  290. IDL::Parser parser(webgl_context_idl_path, StringView(webgl_context_idl_file_content), import_base_paths);
  291. auto const& interface = parser.parse();
  292. auto path = LexicalPath(generated_header_path);
  293. auto title = path.title();
  294. auto first_dot = title.find('.');
  295. ByteString class_name = title;
  296. if (first_dot.has_value())
  297. class_name = title.substring_view(0, *first_dot);
  298. StringBuilder header_file_string_builder;
  299. SourceGenerator header_file_generator { header_file_string_builder };
  300. header_file_generator.set("class_name", class_name);
  301. StringBuilder implementation_file_string_builder;
  302. SourceGenerator implementation_file_generator { implementation_file_string_builder };
  303. implementation_file_generator.set("class_name", class_name);
  304. auto webgl_version = class_name == "WebGLRenderingContextImpl" ? 1 : 2;
  305. if (webgl_version == 1) {
  306. implementation_file_generator.append(R"~~~(
  307. #include <GLES2/gl2.h>
  308. #include <GLES2/gl2ext.h>
  309. )~~~");
  310. } else {
  311. implementation_file_generator.append(R"~~~(
  312. #include <GLES3/gl3.h>
  313. )~~~");
  314. }
  315. implementation_file_generator.append(R"~~~(
  316. #include <LibJS/Runtime/ArrayBuffer.h>
  317. #include <LibJS/Runtime/DataView.h>
  318. #include <LibJS/Runtime/TypedArray.h>
  319. #include <LibWeb/HTML/HTMLCanvasElement.h>
  320. #include <LibWeb/HTML/HTMLImageElement.h>
  321. #include <LibWeb/HTML/HTMLVideoElement.h>
  322. #include <LibWeb/HTML/ImageBitmap.h>
  323. #include <LibWeb/HTML/ImageData.h>
  324. #include <LibWeb/WebGL/OpenGLContext.h>
  325. #include <LibWeb/WebGL/WebGLActiveInfo.h>
  326. #include <LibWeb/WebGL/WebGLBuffer.h>
  327. #include <LibWeb/WebGL/WebGLFramebuffer.h>
  328. #include <LibWeb/WebGL/WebGLProgram.h>
  329. #include <LibWeb/WebGL/WebGLRenderbuffer.h>
  330. #include <LibWeb/WebGL/@class_name@.h>
  331. #include <LibWeb/WebGL/WebGLSampler.h>
  332. #include <LibWeb/WebGL/WebGLShader.h>
  333. #include <LibWeb/WebGL/WebGLSync.h>
  334. #include <LibWeb/WebGL/WebGLShaderPrecisionFormat.h>
  335. #include <LibWeb/WebGL/WebGLTexture.h>
  336. #include <LibWeb/WebGL/WebGLUniformLocation.h>
  337. #include <LibWeb/WebGL/WebGLVertexArrayObject.h>
  338. #include <LibWeb/WebIDL/Buffers.h>
  339. namespace Web::WebGL {
  340. static Vector<GLchar> null_terminated_string(StringView string)
  341. {
  342. Vector<GLchar> result;
  343. for (auto c : string.bytes())
  344. result.append(c);
  345. result.append('\\0');
  346. return result;
  347. }
  348. @class_name@::@class_name@(JS::Realm& realm, NonnullOwnPtr<OpenGLContext> context)
  349. : m_realm(realm)
  350. , m_context(move(context))
  351. {
  352. }
  353. )~~~");
  354. header_file_generator.append(R"~~~(
  355. #pragma once
  356. #include <AK/NonnullOwnPtr.h>
  357. #include <LibGC/Ptr.h>
  358. #include <LibGfx/Bitmap.h>
  359. #include <LibWeb/Bindings/PlatformObject.h>
  360. #include <LibWeb/Forward.h>
  361. #include <LibWeb/WebIDL/Types.h>
  362. namespace Web::WebGL {
  363. using namespace Web::HTML;
  364. class @class_name@ {
  365. public:
  366. @class_name@(JS::Realm&, NonnullOwnPtr<OpenGLContext>);
  367. OpenGLContext& context() { return *m_context; }
  368. virtual void present() = 0;
  369. virtual void needs_to_present() = 0;
  370. virtual void set_error(GLenum) = 0;
  371. )~~~");
  372. for (auto const& function : interface.functions) {
  373. if (function.extended_attributes.contains("FIXME")) {
  374. continue;
  375. }
  376. if (function.name == "getSupportedExtensions"sv || function.name == "getExtension"sv || function.name == "getContextAttributes"sv || function.name == "isContextLost"sv) {
  377. // Implemented in WebGLRenderingContext
  378. continue;
  379. }
  380. StringBuilder function_declaration;
  381. StringBuilder function_parameters;
  382. for (size_t i = 0; i < function.parameters.size(); ++i) {
  383. auto const& parameter = function.parameters[i];
  384. function_parameters.append(to_cpp_type(*parameter.type, interface));
  385. function_parameters.append(" "sv);
  386. function_parameters.append(parameter.name.to_snakecase());
  387. if (i != function.parameters.size() - 1) {
  388. function_parameters.append(", "sv);
  389. }
  390. }
  391. auto function_name = function.name.to_snakecase();
  392. function_declaration.append(to_cpp_type(*function.return_type, interface));
  393. function_declaration.append(" "sv);
  394. function_declaration.append(function_name);
  395. function_declaration.append("("sv);
  396. function_declaration.append(function_parameters.string_view());
  397. function_declaration.append(");"sv);
  398. header_file_generator.append(" "sv);
  399. header_file_generator.append(function_declaration.string_view());
  400. header_file_generator.append("\n"sv);
  401. StringBuilder function_impl;
  402. SourceGenerator function_impl_generator { function_impl };
  403. function_impl_generator.set("class_name", class_name);
  404. ScopeGuard function_guard { [&] {
  405. function_impl_generator.append("}\n"sv);
  406. implementation_file_generator.append(function_impl_generator.as_string_view().bytes());
  407. } };
  408. function_impl_generator.set("function_name", function_name);
  409. function_impl_generator.set("function_parameters", function_parameters.string_view());
  410. function_impl_generator.set("function_return_type", to_cpp_type(*function.return_type, interface));
  411. function_impl_generator.append(R"~~~(
  412. @function_return_type@ @class_name@::@function_name@(@function_parameters@)
  413. {
  414. m_context->make_current();
  415. )~~~");
  416. if (gl_function_modifies_framebuffer(function.name)) {
  417. function_impl_generator.append(" m_context->notify_content_will_change();\n"sv);
  418. }
  419. if (function.name == "createBuffer"sv) {
  420. function_impl_generator.append(R"~~~(
  421. GLuint handle = 0;
  422. glGenBuffers(1, &handle);
  423. return WebGLBuffer::create(m_realm, handle);
  424. )~~~");
  425. continue;
  426. }
  427. if (function.name == "createTexture"sv) {
  428. function_impl_generator.append(R"~~~(
  429. GLuint handle = 0;
  430. glGenTextures(1, &handle);
  431. return WebGLTexture::create(m_realm, handle);
  432. )~~~");
  433. continue;
  434. }
  435. if (function.name == "createFramebuffer"sv) {
  436. function_impl_generator.append(R"~~~(
  437. GLuint handle = 0;
  438. glGenFramebuffers(1, &handle);
  439. return WebGLFramebuffer::create(m_realm, handle);
  440. )~~~");
  441. continue;
  442. }
  443. if (function.name == "createRenderbuffer"sv) {
  444. function_impl_generator.append(R"~~~(
  445. GLuint handle = 0;
  446. glGenRenderbuffers(1, &handle);
  447. return WebGLRenderbuffer::create(m_realm, handle);
  448. )~~~");
  449. continue;
  450. }
  451. if (function.name == "createVertexArray"sv) {
  452. function_impl_generator.append(R"~~~(
  453. GLuint handle = 0;
  454. glGenVertexArrays(1, &handle);
  455. return WebGLVertexArrayObject::create(m_realm, handle);
  456. )~~~");
  457. continue;
  458. }
  459. if (function.name == "createSampler"sv) {
  460. function_impl_generator.append(R"~~~(
  461. GLuint handle = 0;
  462. glGenSamplers(1, &handle);
  463. return WebGLSampler::create(m_realm, handle);
  464. )~~~");
  465. continue;
  466. }
  467. if (function.name == "fenceSync"sv) {
  468. function_impl_generator.append(R"~~~(
  469. GLsync handle = glFenceSync(condition, flags);
  470. return WebGLSync::create(m_realm, handle);
  471. )~~~");
  472. continue;
  473. }
  474. if (function.name == "shaderSource"sv) {
  475. function_impl_generator.append(R"~~~(
  476. Vector<GLchar*> strings;
  477. auto string = null_terminated_string(source);
  478. strings.append(string.data());
  479. Vector<GLint> length;
  480. length.append(source.bytes().size());
  481. glShaderSource(shader->handle(), 1, strings.data(), length.data());
  482. )~~~");
  483. continue;
  484. }
  485. if (function.name == "vertexAttribPointer"sv) {
  486. function_impl_generator.append(R"~~~(
  487. glVertexAttribPointer(index, size, type, normalized, stride, reinterpret_cast<void*>(offset));
  488. )~~~");
  489. continue;
  490. }
  491. if (function.name == "texStorage2D") {
  492. function_impl_generator.append(R"~~~(
  493. glTexStorage2D(target, levels, internalformat, width, height);
  494. )~~~");
  495. continue;
  496. }
  497. if (function.name == "texImage2D"sv && function.overload_index == 0) {
  498. function_impl_generator.append(R"~~~(
  499. void const* pixels_ptr = nullptr;
  500. if (pixels) {
  501. auto const& viewed_array_buffer = pixels->viewed_array_buffer();
  502. auto const& byte_buffer = viewed_array_buffer->buffer();
  503. pixels_ptr = byte_buffer.data();
  504. }
  505. glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels_ptr);
  506. )~~~");
  507. continue;
  508. }
  509. if (function.name == "texImage3D"sv) {
  510. // FIXME: If a WebGLBuffer is bound to the PIXEL_UNPACK_BUFFER target, generates an INVALID_OPERATION error.
  511. // FIXME: If srcData is null, a buffer of sufficient size initialized to 0 is passed.
  512. // FIXME: If type is specified as FLOAT_32_UNSIGNED_INT_24_8_REV, srcData must be null; otherwise, generates an INVALID_OPERATION error.
  513. // FIXME: If srcData is non-null, the type of srcData must match the type according to the above table; otherwise, generate an INVALID_OPERATION error.
  514. // FIXME: If an attempt is made to call this function with no WebGLTexture bound (see above), generates an INVALID_OPERATION error.
  515. // FIXME: If there's not enough data in srcData starting at srcOffset, generate INVALID_OPERATION.
  516. function_impl_generator.append(R"~~~(
  517. void const* src_data_ptr = nullptr;
  518. if (src_data) {
  519. auto const& viewed_array_buffer = src_data->viewed_array_buffer();
  520. auto const& byte_buffer = viewed_array_buffer->buffer();
  521. src_data_ptr = byte_buffer.data();
  522. }
  523. glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, src_data_ptr);
  524. )~~~");
  525. continue;
  526. }
  527. if (function.name == "texImage2D"sv && function.overload_index == 1) {
  528. // FIXME: If this function is called with an ImageData whose data attribute has been neutered,
  529. // an INVALID_VALUE error is generated.
  530. // FIXME: If this function is called with an ImageBitmap that has been neutered, an INVALID_VALUE
  531. // error is generated.
  532. // FIXME: If this function is called with an HTMLImageElement or HTMLVideoElement whose origin
  533. // differs from the origin of the containing Document, or with an HTMLCanvasElement,
  534. // ImageBitmap or OffscreenCanvas whose bitmap's origin-clean flag is set to false,
  535. // a SECURITY_ERR exception must be thrown. See Origin Restrictions.
  536. // FIXME: If source is null then an INVALID_VALUE error is generated.
  537. function_impl_generator.append(R"~~~(
  538. auto bitmap = source.visit(
  539. [](GC::Root<HTMLImageElement> const& source) -> RefPtr<Gfx::ImmutableBitmap> {
  540. return source->immutable_bitmap();
  541. },
  542. [](GC::Root<HTMLCanvasElement> const& source) -> RefPtr<Gfx::ImmutableBitmap> {
  543. auto surface = source->surface();
  544. if (!surface)
  545. return {};
  546. auto bitmap = MUST(Gfx::Bitmap::create(Gfx::BitmapFormat::RGBA8888, Gfx::AlphaType::Premultiplied, surface->size()));
  547. surface->read_into_bitmap(*bitmap);
  548. return Gfx::ImmutableBitmap::create(*bitmap);
  549. },
  550. [](GC::Root<HTMLVideoElement> const& source) -> RefPtr<Gfx::ImmutableBitmap> {
  551. return Gfx::ImmutableBitmap::create(*source->bitmap());
  552. },
  553. [](GC::Root<ImageBitmap> const& source) -> RefPtr<Gfx::ImmutableBitmap> {
  554. return Gfx::ImmutableBitmap::create(*source->bitmap());
  555. },
  556. [](GC::Root<ImageData> const& source) -> RefPtr<Gfx::ImmutableBitmap> {
  557. return Gfx::ImmutableBitmap::create(source->bitmap());
  558. });
  559. if (!bitmap)
  560. return;
  561. void const* pixels_ptr = bitmap->bitmap()->begin();
  562. int width = bitmap->width();
  563. int height = bitmap->height();
  564. glTexImage2D(target, level, internalformat, width, height, 0, format, type, pixels_ptr);
  565. )~~~");
  566. continue;
  567. }
  568. if (function.name == "texSubImage2D"sv && function.overload_index == 0) {
  569. function_impl_generator.append(R"~~~(
  570. void const* pixels_ptr = nullptr;
  571. if (pixels) {
  572. auto const& viewed_array_buffer = pixels->viewed_array_buffer();
  573. auto const& byte_buffer = viewed_array_buffer->buffer();
  574. pixels_ptr = byte_buffer.data();
  575. }
  576. glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels_ptr);
  577. )~~~");
  578. continue;
  579. }
  580. if (function.name == "getShaderParameter"sv) {
  581. function_impl_generator.append(R"~~~(
  582. GLint result = 0;
  583. glGetShaderiv(shader->handle(), pname, &result);
  584. return JS::Value(result);
  585. )~~~");
  586. continue;
  587. }
  588. if (function.name == "getProgramParameter"sv) {
  589. function_impl_generator.append(R"~~~(
  590. GLint result = 0;
  591. glGetProgramiv(program->handle(), pname, &result);
  592. return JS::Value(result);
  593. )~~~");
  594. continue;
  595. }
  596. if (function.name == "bufferData"sv && function.overload_index == 0) {
  597. function_impl_generator.append(R"~~~(
  598. glBufferData(target, size, 0, usage);
  599. )~~~");
  600. continue;
  601. }
  602. if (function.name == "readPixels"sv) {
  603. function_impl_generator.append(R"~~~(
  604. if (!pixels) {
  605. return;
  606. }
  607. void *ptr = nullptr;
  608. if (pixels->is_data_view()) {
  609. auto& data_view = static_cast<JS::DataView&>(*pixels->raw_object());
  610. ptr = data_view.viewed_array_buffer()->buffer().data();
  611. } else if (pixels->is_typed_array_base()) {
  612. auto& typed_array_base = static_cast<JS::TypedArrayBase&>(*pixels->raw_object());
  613. ptr = typed_array_base.viewed_array_buffer()->buffer().data();
  614. } else {
  615. VERIFY_NOT_REACHED();
  616. }
  617. glReadPixels(x, y, width, height, format, type, ptr);
  618. )~~~");
  619. continue;
  620. }
  621. if (function.name == "drawElements"sv) {
  622. function_impl_generator.append(R"~~~(
  623. glDrawElements(mode, count, type, reinterpret_cast<void*>(offset));
  624. needs_to_present();
  625. )~~~");
  626. continue;
  627. }
  628. if (function.name == "drawBuffers"sv) {
  629. function_impl_generator.append(R"~~~(
  630. glDrawBuffers(buffers.size(), buffers.data());
  631. )~~~");
  632. continue;
  633. }
  634. if (function.name.starts_with("uniformMatrix"sv)) {
  635. auto number_of_matrix_elements = function.name.substring_view(13, 1);
  636. function_impl_generator.set("number_of_matrix_elements", number_of_matrix_elements);
  637. if (webgl_version == 1) {
  638. function_impl_generator.set("array_argument_name", "value");
  639. } else {
  640. function_impl_generator.set("array_argument_name", "data");
  641. }
  642. function_impl_generator.append(R"~~~(
  643. auto matrix_size = @number_of_matrix_elements@ * @number_of_matrix_elements@;
  644. float const* raw_data = nullptr;
  645. u64 count = 0;
  646. if (@array_argument_name@.has<Vector<float>>()) {
  647. auto& vector_data = @array_argument_name@.get<Vector<float>>();
  648. raw_data = vector_data.data();
  649. count = vector_data.size() / matrix_size;
  650. } else {
  651. auto& typed_array_base = static_cast<JS::TypedArrayBase&>(*@array_argument_name@.get<GC::Root<WebIDL::BufferSource>>()->raw_object());
  652. auto& float32_array = verify_cast<JS::Float32Array>(typed_array_base);
  653. raw_data = float32_array.data().data();
  654. count = float32_array.array_length().length() / matrix_size;
  655. }
  656. )~~~");
  657. if (webgl_version == 2) {
  658. function_impl_generator.append(R"~~~(
  659. raw_data += src_offset;
  660. if (src_length == 0) {
  661. count -= src_offset;
  662. }
  663. if (src_offset + src_length <= count) {
  664. set_error(GL_INVALID_VALUE);
  665. return;
  666. }
  667. )~~~");
  668. }
  669. function_impl_generator.append(R"~~~(
  670. glUniformMatrix@number_of_matrix_elements@fv(location->handle(), count, transpose, raw_data);
  671. )~~~");
  672. continue;
  673. }
  674. if (function.name == "uniform1fv"sv || function.name == "uniform2fv"sv || function.name == "uniform3fv"sv || function.name == "uniform4fv"sv || function.name == "uniform1iv"sv || function.name == "uniform2iv"sv || function.name == "uniform3iv"sv || function.name == "uniform4iv"sv) {
  675. auto number_of_vector_elements = function.name.substring_view(7, 1);
  676. auto element_type = function.name.substring_view(8, 1);
  677. if (element_type == "f"sv) {
  678. function_impl_generator.set("cpp_element_type", "float"sv);
  679. function_impl_generator.set("typed_array_type", "Float32Array"sv);
  680. function_impl_generator.set("gl_postfix", "f"sv);
  681. } else if (element_type == "i"sv) {
  682. function_impl_generator.set("cpp_element_type", "int"sv);
  683. function_impl_generator.set("typed_array_type", "Int32Array"sv);
  684. function_impl_generator.set("gl_postfix", "i"sv);
  685. } else {
  686. VERIFY_NOT_REACHED();
  687. }
  688. function_impl_generator.set("number_of_vector_elements", number_of_vector_elements);
  689. function_impl_generator.append(R"~~~(
  690. @cpp_element_type@ const* data = nullptr;
  691. size_t count = 0;
  692. if (v.has<Vector<@cpp_element_type@>>()) {
  693. auto& vector = v.get<Vector<@cpp_element_type@>>();
  694. data = vector.data();
  695. count = vector.size();
  696. } else if (v.has<GC::Root<WebIDL::BufferSource>>()) {
  697. auto& typed_array_base = static_cast<JS::TypedArrayBase&>(*v.get<GC::Root<WebIDL::BufferSource>>()->raw_object());
  698. auto& typed_array = verify_cast<JS::@typed_array_type@>(typed_array_base);
  699. data = typed_array.data().data();
  700. count = typed_array.array_length().length();
  701. } else {
  702. VERIFY_NOT_REACHED();
  703. }
  704. )~~~");
  705. if (webgl_version == 2) {
  706. function_impl_generator.append(R"~~~(
  707. data += src_offset;
  708. if (src_length == 0) {
  709. count -= src_offset;
  710. }
  711. if (src_offset + src_length <= count) {
  712. set_error(GL_INVALID_VALUE);
  713. return;
  714. }
  715. )~~~");
  716. }
  717. function_impl_generator.append(R"~~~(
  718. glUniform@number_of_vector_elements@@gl_postfix@v(location->handle(), count / @number_of_vector_elements@, data);
  719. )~~~");
  720. continue;
  721. }
  722. if (function.name == "vertexAttrib1fv"sv || function.name == "vertexAttrib2fv"sv || function.name == "vertexAttrib3fv"sv || function.name == "vertexAttrib4fv"sv) {
  723. auto number_of_vector_elements = function.name.substring_view(12, 1);
  724. function_impl_generator.set("number_of_vector_elements", number_of_vector_elements);
  725. function_impl_generator.append(R"~~~(
  726. if (values.has<Vector<float>>()) {
  727. auto& data = values.get<Vector<float>>();
  728. glVertexAttrib@number_of_vector_elements@fv(index, data.data());
  729. return;
  730. }
  731. auto& typed_array_base = static_cast<JS::TypedArrayBase&>(*values.get<GC::Root<WebIDL::BufferSource>>()->raw_object());
  732. auto& float32_array = verify_cast<JS::Float32Array>(typed_array_base);
  733. float const* data = float32_array.data().data();
  734. glVertexAttrib@number_of_vector_elements@fv(index, data);
  735. )~~~");
  736. continue;
  737. }
  738. if (function.name == "getParameter"sv) {
  739. generate_get_parameter(function_impl_generator, webgl_version);
  740. continue;
  741. }
  742. if (function.name == "getBufferParameter"sv) {
  743. generate_get_buffer_parameter(function_impl_generator);
  744. continue;
  745. }
  746. if (function.name == "getActiveUniform"sv) {
  747. function_impl_generator.append(R"~~~(
  748. GLint size = 0;
  749. GLenum type = 0;
  750. GLsizei buf_size = 256;
  751. GLsizei length = 0;
  752. GLchar name[256];
  753. glGetActiveUniform(program->handle(), index, buf_size, &length, &size, &type, name);
  754. auto readonly_bytes = ReadonlyBytes { name, static_cast<size_t>(length) };
  755. return WebGLActiveInfo::create(m_realm, String::from_utf8_without_validation(readonly_bytes), type, size);
  756. )~~~");
  757. continue;
  758. }
  759. if (function.name == "getActiveAttrib"sv) {
  760. function_impl_generator.append(R"~~~(
  761. GLint size = 0;
  762. GLenum type = 0;
  763. GLsizei buf_size = 256;
  764. GLsizei length = 0;
  765. GLchar name[256];
  766. glGetActiveAttrib(program->handle(), index, buf_size, &length, &size, &type, name);
  767. auto readonly_bytes = ReadonlyBytes { name, static_cast<size_t>(length) };
  768. return WebGLActiveInfo::create(m_realm, String::from_utf8_without_validation(readonly_bytes), type, size);
  769. )~~~");
  770. continue;
  771. }
  772. if (function.name == "getShaderInfoLog"sv) {
  773. function_impl_generator.append(R"~~~(
  774. GLint info_log_length = 0;
  775. glGetShaderiv(shader->handle(), GL_INFO_LOG_LENGTH, &info_log_length);
  776. Vector<GLchar> info_log;
  777. info_log.resize(info_log_length);
  778. if (!info_log_length)
  779. return String {};
  780. glGetShaderInfoLog(shader->handle(), info_log_length, nullptr, info_log.data());
  781. return String::from_utf8_without_validation(ReadonlyBytes { info_log.data(), static_cast<size_t>(info_log_length - 1) });
  782. )~~~");
  783. continue;
  784. }
  785. if (function.name == "getProgramInfoLog"sv) {
  786. function_impl_generator.append(R"~~~(
  787. GLint info_log_length = 0;
  788. glGetProgramiv(program->handle(), GL_INFO_LOG_LENGTH, &info_log_length);
  789. Vector<GLchar> info_log;
  790. info_log.resize(info_log_length);
  791. if (!info_log_length)
  792. return String {};
  793. glGetProgramInfoLog(program->handle(), info_log_length, nullptr, info_log.data());
  794. return String::from_utf8_without_validation(ReadonlyBytes { info_log.data(), static_cast<size_t>(info_log_length - 1) });
  795. )~~~");
  796. continue;
  797. }
  798. if (function.name == "getShaderPrecisionFormat"sv) {
  799. function_impl_generator.append(R"~~~(
  800. GLint range[2];
  801. GLint precision;
  802. glGetShaderPrecisionFormat(shadertype, precisiontype, range, &precision);
  803. return WebGLShaderPrecisionFormat::create(m_realm, range[0], range[1], precision);
  804. )~~~");
  805. continue;
  806. }
  807. if (function.name == "deleteBuffer"sv) {
  808. function_impl_generator.append(R"~~~(
  809. auto handle = buffer ? buffer->handle() : 0;
  810. glDeleteBuffers(1, &handle);
  811. )~~~");
  812. continue;
  813. }
  814. if (function.name == "deleteFramebuffer"sv) {
  815. function_impl_generator.append(R"~~~(
  816. auto handle = framebuffer ? framebuffer->handle() : 0;
  817. glDeleteFramebuffers(1, &handle);
  818. )~~~");
  819. continue;
  820. }
  821. if (function.name == "deleteTexture"sv) {
  822. function_impl_generator.append(R"~~~(
  823. auto handle = texture ? texture->handle() : 0;
  824. glDeleteTextures(1, &handle);
  825. )~~~");
  826. continue;
  827. }
  828. if (function.name == "deleteVertexArray"sv) {
  829. function_impl_generator.append(R"~~~(
  830. auto handle = vertex_array ? vertex_array->handle() : 0;
  831. glDeleteVertexArrays(1, &handle);
  832. )~~~");
  833. continue;
  834. }
  835. Vector<ByteString> gl_call_arguments;
  836. for (size_t i = 0; i < function.parameters.size(); ++i) {
  837. auto const& parameter = function.parameters[i];
  838. auto parameter_name = parameter.name.to_snakecase();
  839. if (parameter.type->is_numeric() || parameter.type->is_boolean()) {
  840. gl_call_arguments.append(parameter_name);
  841. continue;
  842. }
  843. if (parameter.type->is_string()) {
  844. function_impl_generator.set("parameter_name", parameter_name);
  845. function_impl_generator.append(R"~~~(
  846. auto @parameter_name@_null_terminated = null_terminated_string(@parameter_name@);
  847. )~~~");
  848. gl_call_arguments.append(ByteString::formatted("{}_null_terminated.data()", parameter_name));
  849. continue;
  850. }
  851. if (is_webgl_object_type(parameter.type->name())) {
  852. gl_call_arguments.append(ByteString::formatted("{} ? {}->handle() : 0", parameter_name, parameter_name));
  853. continue;
  854. }
  855. if (parameter.type->name() == "WebGLSync"sv) {
  856. // FIXME: Remove the GLsync cast once sync_handle actually returns the proper GLsync type.
  857. gl_call_arguments.append(ByteString::formatted("(GLsync)({} ? {}->sync_handle() : nullptr)", parameter_name, parameter_name));
  858. continue;
  859. }
  860. if (parameter.type->name() == "BufferSource"sv) {
  861. function_impl_generator.set("buffer_source_name", parameter_name);
  862. function_impl_generator.append(R"~~~(
  863. void const* ptr = nullptr;
  864. size_t byte_size = 0;
  865. if (@buffer_source_name@->is_typed_array_base()) {
  866. auto& typed_array_base = static_cast<JS::TypedArrayBase&>(*@buffer_source_name@->raw_object());
  867. ptr = typed_array_base.viewed_array_buffer()->buffer().data();
  868. byte_size = typed_array_base.viewed_array_buffer()->byte_length();
  869. } else if (@buffer_source_name@->is_data_view()) {
  870. auto& data_view = static_cast<JS::DataView&>(*@buffer_source_name@->raw_object());
  871. ptr = data_view.viewed_array_buffer()->buffer().data();
  872. byte_size = data_view.viewed_array_buffer()->byte_length();
  873. } else if (@buffer_source_name@->is_array_buffer()) {
  874. auto& array_buffer = static_cast<JS::ArrayBuffer&>(*@buffer_source_name@->raw_object());
  875. ptr = array_buffer.buffer().data();
  876. byte_size = array_buffer.byte_length();
  877. } else {
  878. VERIFY_NOT_REACHED();
  879. }
  880. )~~~");
  881. gl_call_arguments.append(ByteString::formatted("byte_size"));
  882. gl_call_arguments.append(ByteString::formatted("ptr"));
  883. continue;
  884. }
  885. VERIFY_NOT_REACHED();
  886. }
  887. StringBuilder gl_call_arguments_string_builder;
  888. gl_call_arguments_string_builder.join(", "sv, gl_call_arguments);
  889. auto gl_call_string = ByteString::formatted("{}({})", idl_to_gl_function_name(function.name), gl_call_arguments_string_builder.string_view());
  890. function_impl_generator.set("call_string", gl_call_string);
  891. if (gl_function_modifies_framebuffer(function.name)) {
  892. function_impl_generator.append(" needs_to_present();\n"sv);
  893. }
  894. if (function.return_type->name() == "undefined"sv) {
  895. function_impl_generator.append(" @call_string@;"sv);
  896. } else if (function.return_type->is_integer() || function.return_type->is_boolean()) {
  897. function_impl_generator.append(" return @call_string@;"sv);
  898. } else if (is_webgl_object_type(function.return_type->name())) {
  899. function_impl_generator.set("return_type_name", function.return_type->name());
  900. function_impl_generator.append(" return @return_type_name@::create(m_realm, @call_string@);"sv);
  901. } else {
  902. VERIFY_NOT_REACHED();
  903. }
  904. function_impl_generator.append("\n"sv);
  905. }
  906. header_file_generator.append(R"~~~(
  907. private:
  908. GC::Ref<JS::Realm> m_realm;
  909. NonnullOwnPtr<OpenGLContext> m_context;
  910. };
  911. }
  912. )~~~");
  913. implementation_file_generator.append(R"~~~(
  914. }
  915. )~~~");
  916. MUST(generated_header_file->write_until_depleted(header_file_generator.as_string_view().bytes()));
  917. MUST(generated_implementation_file->write_until_depleted(implementation_file_generator.as_string_view().bytes()));
  918. return 0;
  919. }