Playing with the meta functions / writing own meta functions

[goto40]

Thank you for your nice talk on CppCon 2023! This is very inspiring!! (Hoping for a "Typescript for C++" ;-) )

When will it be possible to play with own meta functions. It seems to be limited to the existing ones ((temporary alpha limitation) currently the supported names are: interface, ...?

[JohelEGP]

I suspect it's going to take a while: d8c1a50#commitcomment-111968233.

[goto40]

I understand. Thank you.

[realgdman]

I guess if you want to get hands dirty, you can hack into

cppfront/source/reflect.h2

Line 1260 in 083c8a0

// Dispatch

Then create own fixed metafunction using some existing as base, and rebuild cppfront?

[JohelEGP]

That's expensive to iterate (compiling cppfront takes me ~22 s),
so I reduced it to ~½ s with #797 (reply in thread).

[JohelEGP]

You can play around with it directly having reflect.h2 as mentioned at #789 (comment).
Or you can use #797, an effort also spurred on by this discussion.

The current reflection API works pretty well for the built-in metafunctions.
But I would personally like it to do more.

In particular, I'd like to reduce the boilerplate of the shim I'm writing.
I can generate the initializer for over 90% of the functions signatures I've wrapped so far.
But the reflection API doesn't

• provide the range of parameters, and
• allow setting the initializer.

Before, I wrote a similar shim with TMP for a different library:

waarudo.pixel_game_engine.cpp

The relevant bits:

#include <olcPixelGameEngine.h>

export module waarudo.pixel_game_engine;

template<class T> constexpr bool is_pge_argument{
  std::is_scalar_v<T> or std::is_same_v<T, olc::Pixel> or std::is_same_v<T, std::string> or
  std::is_same_v<T, olc::vf2d> or std::is_same_v<T, std::array<olc::vf2d, 4>>};

[[nodiscard]] olc::vf2d as_pge_argument(const pge_point<float> v) { return {v.x.number, v.y.number}; }
[[nodiscard]] olc::vf2d as_pge_argument(const pge_vector<float> v) { return {v.x.number, v.y.number}; }

template<bool B, class T> [[nodiscard]] constexpr auto pge_arguments_tie(const T& v) {
  if constexpr (is_pge_argument<T>) return std::tie(v);
  else if constexpr (B and requires { as_pge_argument(v); }) {
    static_assert(is_pge_argument<decltype(as_pge_argument(v))>);
    return std::tuple{as_pge_argument(v)};
  } else return boost::pfr::structure_tie(v);
}

template<bool B = false, class... T> [[nodiscard]] constexpr decltype(auto) pge_call(const auto f, const T&... v) {
  if constexpr ((... and is_pge_argument<T>)) return std::invoke(f, v...);
  else return std::apply([&](const auto&... x) { return pge_call<B>(f, x...); }, tuple_cat(pge_arguments_tie<B>(v)...));
}

export class pixel_game_engine : public olc::PixelGameEngine {
public:
  void construct(const construct_arguments& args) { expects(pge_call(&PixelGameEngine::Construct, this, args)); }

  gui_window_point window_mouse() const { return from_olc(GetWindowMouse()); }
  pge_point<std::int32_t> mouse() const { return from_olc(GetMousePos()); }

  void screen_size(pge_vector<std::int32_t> v) { pge_call(&PixelGameEngine::SetScreenSize, this, v); }

  gui_vector window_size() const { return from_olc(GetWindowSize()); }
  gui_vector pixel_size() const { return from_olc(GetPixelSize()); }
  gui_vector screen_pixel_size() const { return from_olc(GetScreenPixelSize()); }

#define WAARUDO_PGE_LIFT(F) [](auto* pge, auto... arg) { return pge->F(arg...); }

  void draw_decal(_draw_string_args<float, pge_vector<float>{.x{1}, .y{1}}> s) {
    pge_call<true>(&PixelGameEngine::DrawStringDecal, this, s);
  }
  void draw_decal(_draw_string_prop_args<float, pge_vector<float>{.x{1}, .y{1}}> s) {
    pge_call<true>(&PixelGameEngine::DrawStringPropDecal, this, s);
  }

  void draw(_draw_warped_decal_args s) { pge_call<true>(WAARUDO_PGE_LIFT(DrawWarpedDecal), this, s); }
  void draw(_draw_partial_warped_decal_args s) { pge_call<true>(WAARUDO_PGE_LIFT(DrawPartialWarpedDecal), this, s); }
};

module: private;

bool pixel_game_engine::draw(pge_point<std::int32_t> pt, olc::Pixel px) {
  return pge_call(WAARUDO_PGE_LIFT(Draw), this, pt, px);
}
void pixel_game_engine::draw_line(
  pge_point<std::int32_t> a, pge_point<std::int32_t> b, olc::Pixel p, std::uint32_t pattern) {
  pge_call(WAARUDO_PGE_LIFT(DrawLine), this, a, b, p, pattern);
}
void pixel_game_engine::draw_circle(pge_point<std::int32_t> center, pge_radius r, olc::Pixel p, std::uint8_t mask) {
  pge_call(WAARUDO_PGE_LIFT(DrawCircle), this, center, r, p, mask);
}
void pixel_game_engine::fill_circle(pge_point<std::int32_t> center, pge_radius r, olc::Pixel p) {
  pge_call(WAARUDO_PGE_LIFT(FillCircle), this, center, r, p);
}
void pixel_game_engine::draw_rectangle(pge_point<std::int32_t> top_left, pge_vector<std::int32_t> size, olc::Pixel p) {
  pge_call(WAARUDO_PGE_LIFT(DrawRect), this, top_left, size, p);
}
void pixel_game_engine::fill_rectangle(pge_point<std::int32_t> top_left, pge_vector<std::int32_t> size, olc::Pixel p) {
  pge_call(WAARUDO_PGE_LIFT(FillRect), this, top_left, size, p);
}
void pixel_game_engine::draw_triangle(
  pge_point<std::int32_t> vertex0, pge_point<std::int32_t> vertex1, pge_point<std::int32_t> vertex2, olc::Pixel p) {
  pge_call(WAARUDO_PGE_LIFT(DrawTriangle), this, vertex0, vertex1, vertex2, p);
}
void pixel_game_engine::fill_triangle(
  pge_point<std::int32_t> vertex0, pge_point<std::int32_t> vertex1, pge_point<std::int32_t> vertex2, olc::Pixel p) {
  pge_call(WAARUDO_PGE_LIFT(FillTriangle), this, vertex0, vertex1, vertex2, p);
}
void pixel_game_engine::draw_sprite(
  pge_point<std::int32_t> top_left, olc::Sprite* s, pge_pixels<std::uint32_t> scale, olc::Sprite::Flip flip) {
  pge_call(WAARUDO_PGE_LIFT(DrawSprite), this, top_left, s, scale, flip);
}
void pixel_game_engine::draw_partial_sprite(
  pge_point<std::int32_t> window_top_left, olc::Sprite* s, pge_rectangle<std::int32_t> sprite_area,
  pge_pixels<std::uint32_t> scale, olc::Sprite::Flip flip) {
  pge_call(WAARUDO_PGE_LIFT(DrawPartialSprite), this, window_top_left, s, sprite_area, scale, flip);
}
void pixel_game_engine::draw_string(
  pge_point<std::int32_t> top_left, const std::string& text, olc::Pixel p, pge_pixels<std::uint32_t> scale) {
  pge_call(WAARUDO_PGE_LIFT(DrawString), this, top_left, text, p, scale);
}
pge_vector<std::int32_t> pixel_game_engine::text_size(const std::string& s) { return from_olc(GetTextSize(s)); }
void pixel_game_engine::draw_string_prop(
  pge_point<std::int32_t> top_left, const std::string& text, olc::Pixel p, pge_pixels<std::uint32_t> scale) {
  pge_call(WAARUDO_PGE_LIFT(DrawStringProp), this, top_left, text, p, scale);
}
pge_vector<std::int32_t> pixel_game_engine::text_size_prop(const std::string& s) {
  return from_olc(GetTextSizeProp(s));
}

} // namespace waarudo

SFML 3 is more modern and idiomatic.
With a @sfml metafunction, the result would be even better:

• Specify a signature to have the initializer generated.
  • Code to translate snake_case ↔ (camelCase, TitleCase).
  • Recognize what needs to be (un)wrapped.
  • Among the other things so that it Just Works.
• The @printed and lowered code express intent directly (not hidden behind TMP).

For example, these changes should be possible:

  transformable: @struct <Derived> type = {
    set_position: (inout this, point: jegp::ui::window_point<float>) = derived(this).setPosition(point.to_sfml());
  }
  transformable: @sfml <Derived> type = {
    set_position: (inout this, _: jegp::ui::window_point<float>);
  }

  export sprite: @rule_of_zero type = {
    this: sf::Sprite;
    this: transformable<sprite> = ();

    operator=: (out this, texture: sf::Texture) = sf::Sprite = (texture);
    operator=: (out this, texture: sf::Texture, rectangle: jegp::ui::window_rectangle<i32>) = //
      sf::Sprite = (texture, rectangle.to_sfml());
  }
  export sprite: @sfml<sf::Sprite, transformable> type = {
    operator=: (out this, _: sf::Texture);
    operator=: (out this, _: sf::Texture, _: jegp::ui::window_rectangle<i32>);
  }

  export texture: @struct type = {
    this: sf::Texture = ();

    load_from_image: (inout this, image: sf::Image, rect: canvas_rectangle<i32>) -> bool =
      loadFromImage(image, rect.to_sfml());

    get_size: (this) -> jegp::ui::magnitude_t<i32> = sf::Vector2i(getSize()).from_sfml();
  }
  export texture: @sfml<sf::Texture> type = {
    load_from_image: (inout this, _: sf::Image, _: canvas_rectangle<i32>);

    get_size: (this) -> jegp::ui::magnitude_t<i32> = sf::Vector2i(getSize()).from_sfml();
  }

  export vertex_array: @rule_of_zero type = {
    this: sf::VertexArray = ();

    operator=: (out this) = { }
    operator=: (out this, type: sf::PrimitiveType, vertices: std::ptrdiff_t) = //
      sf::VertexArray = (type, vertices as std::size_t);

    triangles: (size: std::ptrdiff_t) -> vertex_array =
      vertex_array(sf::PrimitiveType::Triangles, size * vertices_in_triangle);

    get_bounds: (this) -> jegp::ui::window_rectangle<float> = getBounds().from_sfml();
  }
  export vertex_array: @sfml<sf::VertexArray> type = {
    operator=: (out this) = { }
    operator=: (out this, type: sf::PrimitiveType, vertices: std::ptrdiff_t) = //
      sf::VertexArray = (type, vertices as std::size_t);

    triangles: (size: std::ptrdiff_t) -> vertex_array =
      vertex_array(sf::PrimitiveType::Triangles, size * vertices_in_triangle);

    get_bounds: (this) -> jegp::ui::window_rectangle<float>;
  }

[JohelEGP]

I'm already implementing this at https://github.com/JohelEGP/cppfront/tree/reflect_function_parameters_and_initializer:

• Provide the range of parameters.
• Allow setting the initializer.

[JohelEGP]

I implemented the @sfml.
Due to #830, I need to keep this members,
rather than letting @sfml<bases> generate them.

module waarudo.sfml.metafunction

export module waarudo.sfml.metafunction;

import jegp.utilities;
import cpp2.reflect;
import std;

using namespace std::views;
using std::ranges::to;

waarudo: namespace = {
sfml: namespace = {

  make_vector: (x, y) :std::vector = (x, y); // Workaround hsutter/cppfront#530.

  // `@sfml`, implements a shim for SFML types.
  export sfml: (inout t: cpp2::meta::type_declaration) = {
    std::cout << "\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~(t.print())$" << std::flush;

    // Generate bases from metafunction template arguments.
    (base_types := 0.iota().transform(:(x) t&$*.get_argument(x)).take_while(std::ranges::size), //
     base_targs := make_vector("".std::string().repeat(1), ("<(t.name())$>").repeat(1 << 16)))
      for zip(base_types, base_targs.join()) do (b) t.add_member("this: (b.first)$(b.second)$ = ();");

    t.jegp::rule_of_zero();

    (copy uninitialized_member_functions := t.get_member_functions().filter(:(x) !x.has_initializer()))
      for uninitialized_member_functions do (copy mf)
        ((move mf).add_initializer("= (mf.this_access())$(mf.sfml_member_name())$(mf.sfml_argument_list())$;"));
    t.remove_marked_members();

    std::cout << t.print() << std::flush;
  }

  this_access: (mf: cpp2::meta::function_declaration) -> std::string = {
    if mf.name() == "operator=" {
      return mf.get_parent().as_type().get_member_objects()[0].type() + " = ";
    } else if mf.get_parent().as_type().get_member_objects().std::ranges::empty() {
      return "derived(this).";
    } else {
      return ();
    }
  }

  sfml_member_name: (mf: cpp2::meta::function_declaration) -> std::string = {
    if mf.name() == "operator=" {
      return ();
    } else if mf.get_parameters().size() == 1 && mf.has_parameter_with_name_and_pass("this", cpp2::passing_style::in) {
      return "(mf.name().to_camel_case())$().from_sfml";
    } else {
      return mf.name().to_camel_case();
    }
  }

  intersperse: (forward r, e) r.transform(:(x) make_vector(e$, x)).join().drop(1);

  sfml_argument_list: (mf: cpp2::meta::function_declaration) -> std::string =
    "(" + mf.get_parameters().drop(1).transform(sfml_argument).intersperse("(',')$ ").join().to<std::string>() + ")";

  sfml_argument: (o: cpp2::meta::object_declaration) -> std::string = {
    sfml_types :== :std::array =
      ("jegp::ui::window_point", "jegp::ui::window_rectangle", "jegp::ui::magnitude_t", "canvas_rectangle",
       "canvas_point", "scene_rectangle");

    if sfml_types.std::ranges::any_of(:(x) o.type()$.starts_with(x)) {
      return "(o.name())$.to_sfml()";
    } else {
      return o.name().std::string();
    }
  }

  to_sentence_case: (r) char(r[0u].std::toupper()) + r.drop(1).to<std::string>();

  accumulate: (forward r, init, f) std::accumulate(forward r.begin(), r.end(), init, f);

  to_title_case: (s: std::string_view) -> std::string = {
    if s.is_snake_case() { return s.split('_').accumulate(std::string(), :(move l, r) l + r.to_sentence_case()); }
    assert(false, "Only `snake_case` is supported.");
    std::unreachable();
  }

  to_camel_case: (s: std::string_view) -> std::string = {
    title := to_title_case(s);
    title[0] = char(std::tolower(title[0]));
    return title;
  }

  is_snake_case: (s: std::string_view) -> bool = s.std::ranges::none_of(:(c) 'A' <= c <= 'Z');

} // namespace sfml
} // namespace waarudo

diff using `@sfml`

diff --git a/sources/waarudo/sfml/sfml.cpp2 b/sources/waarudo/sfml/sfml.cpp2
index 93f2d80..8528551 100644
--- a/sources/waarudo/sfml/sfml.cpp2
+++ b/sources/waarudo/sfml/sfml.cpp2
@@ -28,34 +28,30 @@ sfml: namespace = {

   // Graphics.

-  transformable: @struct @sfml <Derived> type = {
-    set_position: (inout this, point: jegp::ui::window_point<float>) = derived(this).setPosition(point.to_sfml());
+  transformable: @sfml <Derived> type = {
+    set_position: (inout this, point: jegp::ui::window_point<float>);
   }

-  export sprite: @rule_of_zero type = {
-    this: sf::Sprite;
-    this: transformable<sprite> = ();
-
-    operator=: (out this, texture: sf::Texture) = sf::Sprite = (texture);
-    operator=: (out this, texture: sf::Texture, rectangle: jegp::ui::window_rectangle<i32>) = //
-      sf::Sprite = (texture, rectangle.to_sfml());
+  export sprite: @sfml<sf::Sprite, transformable> type = {
+    operator=: (out this, texture: sf::Texture);
+    operator=: (out this, texture: sf::Texture, rectangle: jegp::ui::window_rectangle<i32>);
   }

-  export rectangle_shape: @rule_of_zero type = {
+  export rectangle_shape: @sfml type = {
     this: sf::RectangleShape             = ();
     this: transformable<rectangle_shape> = ();

     operator=: (out this) = { }
-    operator=: (out this, size: jegp::ui::magnitude_t<float>) = sf::RectangleShape = (size.to_sfml());
+    operator=: (out this, size: jegp::ui::magnitude_t<float>);
   }

-  render_target: @struct <Derived> type = {
-    set_view: (inout this, v: view) = derived(this).setView(v);
+  render_target: @sfml <Derived> type = {
+    set_view: (inout this, v: view);

     get_size: (this) -> jegp::ui::magnitude_t<i32> = sf::Vector2i(derived(this).getSize()).from_sfml();
   }

-  export render_texture: @struct type = {
+  export render_texture: @sfml type = {
     this: sf::RenderTexture;
     this: render_target<render_texture>;

@@ -63,26 +59,21 @@ sfml: namespace = {
       sf::RenderTexture::create(sf::Vector2u(size.to_sfml()));
   }

-  export render_window: @struct type = {
-    this: sf::RenderWindow;
-    this: render_target<render_window>;
-  }
+  export render_window: @sfml<sf::RenderWindow, render_target> type = { }

-  export texture: @struct type = {
+  export texture: @sfml type = {
     this: sf::Texture = ();

-    load_from_image: (inout this, image: sf::Image, rect: canvas_rectangle<i32>) -> bool =
-      loadFromImage(image, rect.to_sfml());
+    load_from_image: (inout this, image: sf::Image, rect: canvas_rectangle<i32>) -> bool;

     get_size: (this) -> jegp::ui::magnitude_t<i32> = sf::Vector2i(getSize()).from_sfml();
   }

-  export vertex: @rule_of_zero type = {
+  export vertex: @sfml type = {
     this: sf::Vertex = ();

     operator=: (out this) = { }
-    operator=: (out this, position: jegp::ui::window_point<float>, texture_position: canvas_point<float>) = //
-      sf::Vertex = (position.to_sfml(), texture_position.to_sfml());
+    operator=: (out this, position: jegp::ui::window_point<float>, texture_position: canvas_point<float>);
   }

   export vertex_ptr: @basic_value <Const: bool> type = {
@@ -102,7 +93,7 @@ sfml: namespace = {

   export vertices_in_triangle :== 3;

-  export vertex_array: @rule_of_zero type = {
+  export vertex_array: @sfml type = {
     this: sf::VertexArray = ();

     operator=: (out this) = { }
@@ -112,14 +103,14 @@ sfml: namespace = {
     triangles: (size: std::ptrdiff_t) -> vertex_array =
       vertex_array(sf::PrimitiveType::Triangles, size * vertices_in_triangle);

-    get_bounds: (this) -> jegp::ui::window_rectangle<float> = getBounds().from_sfml();
+    get_bounds: (this) -> jegp::ui::window_rectangle<float>;
   }

-  export view: @rule_of_zero type = {
+  export view: @sfml type = {
     this: sf::View = ();

     operator=: (out this) = { }
-    operator=: (out this, zone_to_display: scene_rectangle<float>) = sf::View = to_sfml(zone_to_display);
+    operator=: (out this, zone_to_display: scene_rectangle<float>);
   }

   to_sfml: <O, Number> (shape: jegp::ui::rectangle<O, Number>) -> sf::Rect<Number> =

Before/after `@print`s

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

transformable: <Derived: type> type =
{
    set_position:(
        inout this,
        in point: jegp::ui::window_point<float>
    );
}

transformable: <Derived: type> type =
{

    set_position:(
        inout this,
        in point: jegp::ui::window_point<float>
    ) = derived(this).setPosition(point.to_sfml());
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

sprite: type =
{
    operator=:(
        out this,
        in texture: sf::Texture
    );

    operator=:(
        out this,
        in texture: sf::Texture,
        in rectangle: jegp::ui::window_rectangle<i32>
    );
}

sprite: type =
{

    this: sf::Sprite = ();

    this: transformable<sprite> = ();

    operator=:(
        out this,
        in texture: sf::Texture
    ) = sf::Sprite = (texture);

    operator=:(
        out this,
        in texture: sf::Texture,
        in rectangle: jegp::ui::window_rectangle<i32>
    ) = sf::Sprite = (texture, rectangle.to_sfml());
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

rectangle_shape: type =
{
    this: sf::RectangleShape = ();

    this: transformable<rectangle_shape> = ();

    operator=:(out this) =
    {
    }

    operator=:(
        out this,
        in size: jegp::ui::magnitude_t<float>
    );
}

rectangle_shape: type =
{

    this: sf::RectangleShape = ();

    this: transformable<rectangle_shape> = ();

    operator=:(out this) =
    {
    }

    operator=:(
        out this,
        in size: jegp::ui::magnitude_t<float>
    ) = sf::RectangleShape = (size.to_sfml());
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

render_target: <Derived: type> type =
{
    set_view:(
        inout this,
        in v: view
    );

    get_size:(in this) -> move jegp::ui::magnitude_t<i32> = sf::Vector2i(derived(this).getSize()).from_sfml();
}

render_target: <Derived: type> type =
{

    get_size:(in this) -> move jegp::ui::magnitude_t<i32> = sf::Vector2i(derived(this).getSize()).from_sfml();

    set_view:(
        inout this,
        in v: view
    ) = derived(this).setView(v);
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

render_texture: type =
{
    this: sf::RenderTexture;

    this: render_target<render_texture>;

    create:(
        inout this,
        in size: jegp::ui::magnitude_t<i32>
    ) -> move bool = sf::RenderTexture::create(sf::Vector2u(size.to_sfml()));
}

render_texture: type =
{

    this: sf::RenderTexture;

    this: render_target<render_texture>;

    create:(
        inout this,
        in size: jegp::ui::magnitude_t<i32>
    ) -> move bool = sf::RenderTexture::create(sf::Vector2u(size.to_sfml()));
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

render_window: type =
{
}

render_window: type =
{
    this: sf::RenderWindow = ();

    this: render_target<render_window> = ();
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

texture: type =
{
    this: sf::Texture = ();

    load_from_image:(
        inout this,
        in image: sf::Image,
        in rect: canvas_rectangle<i32>
    ) -> move bool;

    get_size:(in this) -> move jegp::ui::magnitude_t<i32> = sf::Vector2i(getSize()).from_sfml();
}

texture: type =
{

    this: sf::Texture = ();

    get_size:(in this) -> move jegp::ui::magnitude_t<i32> = sf::Vector2i(getSize()).from_sfml();

    load_from_image:(
        inout this,
        in image: sf::Image,
        in rect: canvas_rectangle<i32>
    ) -> move bool = loadFromImage(image, rect.to_sfml());
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

vertex: type =
{
    this: sf::Vertex = ();

    operator=:(out this) =
    {
    }

    operator=:(
        out this,
        in position: jegp::ui::window_point<float>,
        in texture_position: canvas_point<float>
    );
}

vertex: type =
{

    this: sf::Vertex = ();

    operator=:(out this) =
    {
    }

    operator=:(
        out this,
        in position: jegp::ui::window_point<float>,
        in texture_position: canvas_point<float>
    ) = sf::Vertex = (position.to_sfml(), texture_position.to_sfml());
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

vertex_array: type =
{
    this: sf::VertexArray = ();

    operator=:(out this) =
    {
    }

    operator=:(
        out this,
        in type: sf::PrimitiveType,
        in vertices: std::ptrdiff_t
    ) = sf::VertexArray = (type, vertices as std::size_t);

    triangles:(in size: std::ptrdiff_t) -> move vertex_array = vertex_array(sf::PrimitiveType::Triangles, size * vertices_in_triangle);

    get_bounds:(in this) -> move jegp::ui::window_rectangle<float>;
}

vertex_array: type =
{

    this: sf::VertexArray = ();

    operator=:(out this) =
    {
    }

    operator=:(
        out this,
        in type: sf::PrimitiveType,
        in vertices: std::ptrdiff_t
    ) = sf::VertexArray = (type, vertices as std::size_t);

    triangles:(in size: std::ptrdiff_t) -> move vertex_array = vertex_array(sf::PrimitiveType::Triangles, size * vertices_in_triangle);

    get_bounds:(in this) -> move jegp::ui::window_rectangle<float> = getBounds().from_sfml();
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

view: type =
{
    this: sf::View = ();

    operator=:(out this) =
    {
    }

    operator=:(
        out this,
        in zone_to_display: scene_rectangle<float>
    );
}

view: type =
{

    this: sf::View = ();

    operator=:(out this) =
    {
    }

    operator=:(
        out this,
        in zone_to_display: scene_rectangle<float>
    ) = sf::View = (zone_to_display.to_sfml());
}