Mesh = ref object of GameObject
  data*: MeshData
  materials*: seq[Material]
  material_defines*: Table[string, string]
  passes*: seq[int32]
  armature*: Armature
  draw_method*: MeshDrawMethod
  hash*: string
  layout*: AttributeList
  vertex_modifiers*: seq[VertexModifier]
  mesh_id*: int8
  bone_index_maps*: seq[Table[int32, int32]]
  sort_sign*: SortSign
  shape_names*: seq[string]
  mesh_name*: string
  skip_upload*: bool
  generate_tangents*: bool
  last_polyline_point*, last_polyline_left*: Vec3

MeshData = ref object
  engine* {.cursor.}: MyouEngine
  hash*: string
  varrays*: seq[ArrRef[float32]]
  iarrays*: seq[ArrRef[uint16]]
  loaded*: bool
  draw_method*: MeshDrawMethod
      name*: string

  

MeshDrawMethod = enum
  Points = 0, Lines = 1, LineLoop = 2, LineStrip = 3, Triangles = 4,
  TriangleStrip = 5, TriangleFan = 6

SortSign = enum
  BackToFront = -1, FrontToBack = 1

proc add_modifier(self: Mesh; modifier: VertexModifier) {.
    ...raises: [ValueError, Exception], tags: [RootEffect].}

proc add_polygonal_line(self: Mesh; orig, dest: Vec3; width: float) {.
    ...raises: [ValueError, Exception], tags: [RootEffect].}

proc add_vertex(self: Mesh; position: Vec3; color: Vec4): int {.discardable,
    ...raises: [ValueError], tags: [].}

proc add_vertex(self: Mesh; x, y, z, r, g, b, a: SomeFloat): int {.discardable.}

proc add_vertex(self: Mesh; x, y, z: float32; r, g, b, a: uint8): int {.
    discardable, ...raises: [ValueError], tags: [].}

proc clear_vertices(self: Mesh) {....raises: [], tags: [].}

proc clone(self: Mesh; recursive: bool = true; with_behaviours: bool = true;
           name: string = self.name; new_parent: GameObject = self.parent;
           scene: Scene = self.scene; instance_body: bool = true): Mesh {.
    ...raises: [Exception], tags: [RootEffect].}

proc clone(self: MeshData): MeshData {....raises: [], tags: [].}

proc clone_impl(self: Mesh; clone: Mesh): Mesh {....raises: [], tags: [].}

proc debug_print_vertices(self: Mesh; starts: int = 0; ends: int = 10) {.
    ...raises: [ValueError], tags: [].}

proc ensure_capacity(self: Mesh; extra_elements: int) {....raises: [Exception],
    tags: [RootEffect].}

proc generate_tangents(self: MeshData; uv_layer_name, tangent_layer_name: string) {.
    ...raises: [ValueError, KeyError], tags: [].}

proc gpu_buffers_delete(self: MeshData) {....raises: [Exception],
    tags: [RootEffect].}

proc gpu_buffers_upload(self: MeshData) {....raises: [Exception, ValueError],
    tags: [RootEffect].}

proc initMesh(self: Mesh; engine: MyouEngine; name: string; scene: Scene = nil;
              draw_method: MeshDrawMethod = Triangles;
              common_attributes: CommonMeshAttributes = {vertex, color};
              layout: AttributeList = @[]; skip_upload: bool = false;
              vertex_count: int32 = 0; vertex_array: seq[float32] = @[];
              index_array: seq[uint16] = @[]; pass: int32 = 0): Mesh {.
    ...raises: [Exception], tags: [RootEffect].}

proc insert_modifier(self: Mesh; index: int; modifier: VertexModifier) {.
    ...raises: [ValueError, Exception], tags: [RootEffect].}

proc load_from_va_ia(self: Mesh; varray: seq[float32];
                     iarray: seq[uint16] = @[]; layout: AttributeList = @[]) {.
    ...raises: [Exception, ValueError], tags: [RootEffect].}

proc load_from_va_ia(self: Mesh; varrays: seq[ArrRef[float32]]; iarrays: seq[
    ArrRef[uint16]] |
    seq[ArrRef[int32]] = newSeq[ArrRef[uint16]](); layout: AttributeList = @[];
                     index_types: seq[DataType] = @[])

proc newMesh(engine: MyouEngine; name: string = "mesh"; scene: Scene = nil;
             draw_method: MeshDrawMethod = Triangles;
             common_attributes: CommonMeshAttributes = {vertex, color};
             layout: AttributeList = @[]; skip_upload: bool = false;
             vertex_count: int32 = 0; vertex_array: seq[float32] = @[];
             index_array: seq[uint16] = @[]; pass: int32 = 0): Mesh {.
    ...raises: [Exception], tags: [RootEffect].}

proc remove(self: MeshData; ob: Mesh; delete_buffers: bool = true) {....raises: [],
    tags: [].}

proc remove_modifier(self: Mesh; index: int) {....raises: [], tags: [].}

proc remove_modifier(self: Mesh; modifier: VertexModifier) {....raises: [],
    tags: [].}

proc remove_vertex(self: Mesh; index: int) {....raises: [ValueError], tags: [].}

proc sort_faces(self: Mesh; camera_position: Vec3) {....raises: [], tags: [].}

proc update_bounding_box(self: Mesh) {....raises: [ValueError], tags: [].}

proc update_iarray(self: MeshData) {....raises: [Exception, ValueError],
                                     tags: [RootEffect].}

proc update_varray(self: MeshData) {....raises: [Exception, ValueError],
                                     tags: [RootEffect].}

proc write_vaos(self: MeshData) {....raises: [Exception], tags: [RootEffect].}

method get_mesh(self: GameObject): Mesh {.base, ...raises: [], tags: [].}

method get_mesh(self: Mesh): Mesh {....raises: [], tags: [].}

method is_mesh(self: GameObject): bool {.base, ...raises: [], tags: [].}

method is_mesh(self: Mesh): bool {....raises: [], tags: [].}