const gboxed_types = Any[]
begin
    struct _GrapheneSimd4F
        x::Float32
        y::Float32
        z::Float32
        w::Float32
    end
    mutable struct GrapheneSimd4F
        handle::Ptr{_GrapheneSimd4F}
    end
    begin
        unsafe_convert(::Type{Ptr{_GrapheneSimd4F}}, box::GrapheneSimd4F) = begin
                convert(Ptr{_GrapheneSimd4F}, box.handle)
            end
        convert(::Type{GrapheneSimd4F}, p::Ptr{_GrapheneSimd4F}, owns = false) = begin
                GrapheneSimd4F(p, owns)
            end
        const GrapheneSimd4FLike = Union{Ref{_GrapheneSimd4F}, GrapheneSimd4F}
        convert(::Type{GrapheneSimd4FLike}, p, owns) = begin
                convert(GrapheneSimd4F, p, owns)
            end
    end
end
begin
    struct _GrapheneVec3
        value::_GrapheneSimd4F
    end
    mutable struct GrapheneVec3 <: GBoxed
        handle::Ptr{_GrapheneVec3}
        begin
            (GLib.g_type(::Type{T}) where T <: GrapheneVec3) = begin
                    ccall(("graphene_vec3_get_type", libgraphene), GType, ())
                end
            function GrapheneVec3(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneVec3}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GrapheneVec3)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_GrapheneVec3}}, box::GrapheneVec3) = begin
                convert(Ptr{_GrapheneVec3}, box.handle)
            end
        convert(::Type{GrapheneVec3}, p::Ptr{_GrapheneVec3}, owns = false) = begin
                GrapheneVec3(p, owns)
            end
        const GrapheneVec3Like = Union{Ref{_GrapheneVec3}, GrapheneVec3}
        convert(::Type{GrapheneVec3Like}, p, owns) = begin
                convert(GrapheneVec3, p, owns)
            end
    end
end
begin
    struct _GrapheneSimd4X4F
        x::_GrapheneSimd4F
        y::_GrapheneSimd4F
        z::_GrapheneSimd4F
        w::_GrapheneSimd4F
    end
    mutable struct GrapheneSimd4X4F
        handle::Ptr{_GrapheneSimd4X4F}
    end
    begin
        unsafe_convert(::Type{Ptr{_GrapheneSimd4X4F}}, box::GrapheneSimd4X4F) = begin
                convert(Ptr{_GrapheneSimd4X4F}, box.handle)
            end
        convert(::Type{GrapheneSimd4X4F}, p::Ptr{_GrapheneSimd4X4F}, owns = false) = begin
                GrapheneSimd4X4F(p, owns)
            end
        const GrapheneSimd4X4FLike = Union{Ref{_GrapheneSimd4X4F}, GrapheneSimd4X4F}
        convert(::Type{GrapheneSimd4X4FLike}, p, owns) = begin
                convert(GrapheneSimd4X4F, p, owns)
            end
    end
end
begin
    struct _GrapheneSize
        width::Float32
        height::Float32
    end
    mutable struct GrapheneSize <: GBoxed
        handle::Ptr{_GrapheneSize}
        begin
            (GLib.g_type(::Type{T}) where T <: GrapheneSize) = begin
                    ccall(("graphene_size_get_type", libgraphene), GType, ())
                end
            function GrapheneSize(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneSize}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GrapheneSize)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_GrapheneSize}}, box::GrapheneSize) = begin
                convert(Ptr{_GrapheneSize}, box.handle)
            end
        convert(::Type{GrapheneSize}, p::Ptr{_GrapheneSize}, owns = false) = begin
                GrapheneSize(p, owns)
            end
        const GrapheneSizeLike = Union{Ref{_GrapheneSize}, GrapheneSize}
        convert(::Type{GrapheneSizeLike}, p, owns) = begin
                convert(GrapheneSize, p, owns)
            end
    end
end
begin
    struct _GrapheneBox
        min::_GrapheneVec3
        max::_GrapheneVec3
    end
    mutable struct GrapheneBox <: GBoxed
        handle::Ptr{_GrapheneBox}
        begin
            (GLib.g_type(::Type{T}) where T <: GrapheneBox) = begin
                    ccall(("graphene_box_get_type", libgraphene), GType, ())
                end
            function GrapheneBox(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneBox}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GrapheneBox)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_GrapheneBox}}, box::GrapheneBox) = begin
                convert(Ptr{_GrapheneBox}, box.handle)
            end
        convert(::Type{GrapheneBox}, p::Ptr{_GrapheneBox}, owns = false) = begin
                GrapheneBox(p, owns)
            end
        const GrapheneBoxLike = Union{Ref{_GrapheneBox}, GrapheneBox}
        convert(::Type{GrapheneBoxLike}, p, owns) = begin
                convert(GrapheneBox, p, owns)
            end
    end
end
begin
    struct _GrapheneEuler
        angles::_GrapheneVec3
        order::UInt32
    end
    mutable struct GrapheneEuler <: GBoxed
        handle::Ptr{_GrapheneEuler}
        begin
            (GLib.g_type(::Type{T}) where T <: GrapheneEuler) = begin
                    ccall(("graphene_euler_get_type", libgraphene), GType, ())
                end
            function GrapheneEuler(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneEuler}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GrapheneEuler)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_GrapheneEuler}}, box::GrapheneEuler) = begin
                convert(Ptr{_GrapheneEuler}, box.handle)
            end
        convert(::Type{GrapheneEuler}, p::Ptr{_GrapheneEuler}, owns = false) = begin
                GrapheneEuler(p, owns)
            end
        const GrapheneEulerLike = Union{Ref{_GrapheneEuler}, GrapheneEuler}
        convert(::Type{GrapheneEulerLike}, p, owns) = begin
                convert(GrapheneEuler, p, owns)
            end
    end
end
begin
    mutable struct GrapheneFrustum <: GBoxed
        handle::Ptr{GrapheneFrustum}
        begin
            (GLib.g_type(::Type{T}) where T <: GrapheneFrustum) = begin
                    ccall(("graphene_frustum_get_type", libgraphene), GType, ())
                end
            function GrapheneFrustum(ref::Ptr{T}, own::Bool = false) where T <: GBoxed
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GrapheneFrustum)
        end
    end
    const GrapheneFrustumLike = GrapheneFrustum
    const _GrapheneFrustum = GrapheneFrustum
end
begin
    struct _GrapheneMatrix
        value::_GrapheneSimd4X4F
    end
    mutable struct GrapheneMatrix <: GBoxed
        handle::Ptr{_GrapheneMatrix}
        begin
            (GLib.g_type(::Type{T}) where T <: GrapheneMatrix) = begin
                    ccall(("graphene_matrix_get_type", libgraphene), GType, ())
                end
            function GrapheneMatrix(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneMatrix}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GrapheneMatrix)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_GrapheneMatrix}}, box::GrapheneMatrix) = begin
                convert(Ptr{_GrapheneMatrix}, box.handle)
            end
        convert(::Type{GrapheneMatrix}, p::Ptr{_GrapheneMatrix}, owns = false) = begin
                GrapheneMatrix(p, owns)
            end
        const GrapheneMatrixLike = Union{Ref{_GrapheneMatrix}, GrapheneMatrix}
        convert(::Type{GrapheneMatrixLike}, p, owns) = begin
                convert(GrapheneMatrix, p, owns)
            end
    end
end
begin
    struct _GraphenePlane
        normal::_GrapheneVec3
        constant::Float32
    end
    mutable struct GraphenePlane <: GBoxed
        handle::Ptr{_GraphenePlane}
        begin
            (GLib.g_type(::Type{T}) where T <: GraphenePlane) = begin
                    ccall(("graphene_plane_get_type", libgraphene), GType, ())
                end
            function GraphenePlane(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GraphenePlane}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GraphenePlane)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_GraphenePlane}}, box::GraphenePlane) = begin
                convert(Ptr{_GraphenePlane}, box.handle)
            end
        convert(::Type{GraphenePlane}, p::Ptr{_GraphenePlane}, owns = false) = begin
                GraphenePlane(p, owns)
            end
        const GraphenePlaneLike = Union{Ref{_GraphenePlane}, GraphenePlane}
        convert(::Type{GraphenePlaneLike}, p, owns) = begin
                convert(GraphenePlane, p, owns)
            end
    end
end
begin
    struct _GraphenePoint
        x::Float32
        y::Float32
    end
    mutable struct GraphenePoint <: GBoxed
        handle::Ptr{_GraphenePoint}
        begin
            (GLib.g_type(::Type{T}) where T <: GraphenePoint) = begin
                    ccall(("graphene_point_get_type", libgraphene), GType, ())
                end
            function GraphenePoint(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GraphenePoint}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GraphenePoint)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_GraphenePoint}}, box::GraphenePoint) = begin
                convert(Ptr{_GraphenePoint}, box.handle)
            end
        convert(::Type{GraphenePoint}, p::Ptr{_GraphenePoint}, owns = false) = begin
                GraphenePoint(p, owns)
            end
        const GraphenePointLike = Union{Ref{_GraphenePoint}, GraphenePoint}
        convert(::Type{GraphenePointLike}, p, owns) = begin
                convert(GraphenePoint, p, owns)
            end
    end
end
begin
    struct _GraphenePoint3D
        x::Float32
        y::Float32
        z::Float32
    end
    mutable struct GraphenePoint3D <: GBoxed
        handle::Ptr{_GraphenePoint3D}
        begin
            (GLib.g_type(::Type{T}) where T <: GraphenePoint3D) = begin
                    ccall(("graphene_point3d_get_type", libgraphene), GType, ())
                end
            function GraphenePoint3D(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GraphenePoint3D}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GraphenePoint3D)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_GraphenePoint3D}}, box::GraphenePoint3D) = begin
                convert(Ptr{_GraphenePoint3D}, box.handle)
            end
        convert(::Type{GraphenePoint3D}, p::Ptr{_GraphenePoint3D}, owns = false) = begin
                GraphenePoint3D(p, owns)
            end
        const GraphenePoint3DLike = Union{Ref{_GraphenePoint3D}, GraphenePoint3D}
        convert(::Type{GraphenePoint3DLike}, p, owns) = begin
                convert(GraphenePoint3D, p, owns)
            end
    end
end
begin
    mutable struct GrapheneQuad <: GBoxed
        handle::Ptr{GrapheneQuad}
        begin
            (GLib.g_type(::Type{T}) where T <: GrapheneQuad) = begin
                    ccall(("graphene_quad_get_type", libgraphene), GType, ())
                end
            function GrapheneQuad(ref::Ptr{T}, own::Bool = false) where T <: GBoxed
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GrapheneQuad)
        end
    end
    const GrapheneQuadLike = GrapheneQuad
    const _GrapheneQuad = GrapheneQuad
end
begin
    struct _GrapheneQuaternion
        x::Float32
        y::Float32
        z::Float32
        w::Float32
    end
    mutable struct GrapheneQuaternion <: GBoxed
        handle::Ptr{_GrapheneQuaternion}
        begin
            (GLib.g_type(::Type{T}) where T <: GrapheneQuaternion) = begin
                    ccall(("graphene_quaternion_get_type", libgraphene), GType, ())
                end
            function GrapheneQuaternion(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneQuaternion}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GrapheneQuaternion)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_GrapheneQuaternion}}, box::GrapheneQuaternion) = begin
                convert(Ptr{_GrapheneQuaternion}, box.handle)
            end
        convert(::Type{GrapheneQuaternion}, p::Ptr{_GrapheneQuaternion}, owns = false) = begin
                GrapheneQuaternion(p, owns)
            end
        const GrapheneQuaternionLike = Union{Ref{_GrapheneQuaternion}, GrapheneQuaternion}
        convert(::Type{GrapheneQuaternionLike}, p, owns) = begin
                convert(GrapheneQuaternion, p, owns)
            end
    end
end
begin
    struct _GrapheneRay
        origin::_GrapheneVec3
        direction::_GrapheneVec3
    end
    mutable struct GrapheneRay <: GBoxed
        handle::Ptr{_GrapheneRay}
        begin
            (GLib.g_type(::Type{T}) where T <: GrapheneRay) = begin
                    ccall(("graphene_ray_get_type", libgraphene), GType, ())
                end
            function GrapheneRay(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneRay}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GrapheneRay)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_GrapheneRay}}, box::GrapheneRay) = begin
                convert(Ptr{_GrapheneRay}, box.handle)
            end
        convert(::Type{GrapheneRay}, p::Ptr{_GrapheneRay}, owns = false) = begin
                GrapheneRay(p, owns)
            end
        const GrapheneRayLike = Union{Ref{_GrapheneRay}, GrapheneRay}
        convert(::Type{GrapheneRayLike}, p, owns) = begin
                convert(GrapheneRay, p, owns)
            end
    end
end
begin
    struct _GrapheneRect
        origin::_GraphenePoint
        size::_GrapheneSize
    end
    mutable struct GrapheneRect <: GBoxed
        handle::Ptr{_GrapheneRect}
        begin
            (GLib.g_type(::Type{T}) where T <: GrapheneRect) = begin
                    ccall(("graphene_rect_get_type", libgraphene), GType, ())
                end
            function GrapheneRect(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneRect}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GrapheneRect)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_GrapheneRect}}, box::GrapheneRect) = begin
                convert(Ptr{_GrapheneRect}, box.handle)
            end
        convert(::Type{GrapheneRect}, p::Ptr{_GrapheneRect}, owns = false) = begin
                GrapheneRect(p, owns)
            end
        const GrapheneRectLike = Union{Ref{_GrapheneRect}, GrapheneRect}
        convert(::Type{GrapheneRectLike}, p, owns) = begin
                convert(GrapheneRect, p, owns)
            end
    end
end
begin
    struct _GrapheneSphere
        center::_GrapheneVec3
        radius::Float32
    end
    mutable struct GrapheneSphere <: GBoxed
        handle::Ptr{_GrapheneSphere}
        begin
            (GLib.g_type(::Type{T}) where T <: GrapheneSphere) = begin
                    ccall(("graphene_sphere_get_type", libgraphene), GType, ())
                end
            function GrapheneSphere(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneSphere}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GrapheneSphere)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_GrapheneSphere}}, box::GrapheneSphere) = begin
                convert(Ptr{_GrapheneSphere}, box.handle)
            end
        convert(::Type{GrapheneSphere}, p::Ptr{_GrapheneSphere}, owns = false) = begin
                GrapheneSphere(p, owns)
            end
        const GrapheneSphereLike = Union{Ref{_GrapheneSphere}, GrapheneSphere}
        convert(::Type{GrapheneSphereLike}, p, owns) = begin
                convert(GrapheneSphere, p, owns)
            end
    end
end
begin
    struct _GrapheneTriangle
        a::_GrapheneVec3
        b::_GrapheneVec3
        c::_GrapheneVec3
    end
    mutable struct GrapheneTriangle <: GBoxed
        handle::Ptr{_GrapheneTriangle}
        begin
            (GLib.g_type(::Type{T}) where T <: GrapheneTriangle) = begin
                    ccall(("graphene_triangle_get_type", libgraphene), GType, ())
                end
            function GrapheneTriangle(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneTriangle}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GrapheneTriangle)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_GrapheneTriangle}}, box::GrapheneTriangle) = begin
                convert(Ptr{_GrapheneTriangle}, box.handle)
            end
        convert(::Type{GrapheneTriangle}, p::Ptr{_GrapheneTriangle}, owns = false) = begin
                GrapheneTriangle(p, owns)
            end
        const GrapheneTriangleLike = Union{Ref{_GrapheneTriangle}, GrapheneTriangle}
        convert(::Type{GrapheneTriangleLike}, p, owns) = begin
                convert(GrapheneTriangle, p, owns)
            end
    end
end
begin
    struct _GrapheneVec2
        value::_GrapheneSimd4F
    end
    mutable struct GrapheneVec2 <: GBoxed
        handle::Ptr{_GrapheneVec2}
        begin
            (GLib.g_type(::Type{T}) where T <: GrapheneVec2) = begin
                    ccall(("graphene_vec2_get_type", libgraphene), GType, ())
                end
            function GrapheneVec2(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneVec2}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GrapheneVec2)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_GrapheneVec2}}, box::GrapheneVec2) = begin
                convert(Ptr{_GrapheneVec2}, box.handle)
            end
        convert(::Type{GrapheneVec2}, p::Ptr{_GrapheneVec2}, owns = false) = begin
                GrapheneVec2(p, owns)
            end
        const GrapheneVec2Like = Union{Ref{_GrapheneVec2}, GrapheneVec2}
        convert(::Type{GrapheneVec2Like}, p, owns) = begin
                convert(GrapheneVec2, p, owns)
            end
    end
end
begin
    struct _GrapheneVec4
        value::_GrapheneSimd4F
    end
    mutable struct GrapheneVec4 <: GBoxed
        handle::Ptr{_GrapheneVec4}
        begin
            (GLib.g_type(::Type{T}) where T <: GrapheneVec4) = begin
                    ccall(("graphene_vec4_get_type", libgraphene), GType, ())
                end
            function GrapheneVec4(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneVec4}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GrapheneVec4)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_GrapheneVec4}}, box::GrapheneVec4) = begin
                convert(Ptr{_GrapheneVec4}, box.handle)
            end
        convert(::Type{GrapheneVec4}, p::Ptr{_GrapheneVec4}, owns = false) = begin
                GrapheneVec4(p, owns)
            end
        const GrapheneVec4Like = Union{Ref{_GrapheneVec4}, GrapheneVec4}
        convert(::Type{GrapheneVec4Like}, p, owns) = begin
                convert(GrapheneVec4, p, owns)
            end
    end
end
gboxed_cache_init() = begin
        append!(GLib.gboxed_types, gboxed_types)
    end
const gtype_wrapper_cache = Dict{Symbol, Type}()
begin
    gtype_wrapper_cache_init() = begin
            merge!(GLib.gtype_wrappers, gtype_wrapper_cache)
        end
end
function GrapheneVec3()
    G_.Vec3_alloc()
end
function GrapheneSize()
    G_.Size_alloc()
end
function GrapheneBox()
    G_.Box_alloc()
end
function GrapheneEuler()
    G_.Euler_alloc()
end
function GrapheneFrustum()
    G_.Frustum_alloc()
end
function GrapheneMatrix()
    G_.Matrix_alloc()
end
function GraphenePlane()
    G_.Plane_alloc()
end
function GraphenePoint()
    G_.Point_alloc()
end
function GraphenePoint3D()
    G_.Point3D_alloc()
end
function GrapheneQuad()
    G_.Quad_alloc()
end
function GrapheneQuaternion()
    G_.Quaternion_alloc()
end
function GrapheneRay()
    G_.Ray_alloc()
end
function GrapheneSphere()
    G_.Sphere_alloc()
end
function GrapheneTriangle()
    G_.Triangle_alloc()
end
function GrapheneVec2()
    G_.Vec2_alloc()
end
function GrapheneVec4()
    G_.Vec4_alloc()
end
export GrapheneSimd4F, _GrapheneSimd4F, GrapheneSimd4FLike, GrapheneVec3, _GrapheneVec3, GrapheneVec3Like, GrapheneSimd4X4F, _GrapheneSimd4X4F, GrapheneSimd4X4FLike, GrapheneSize, _GrapheneSize, GrapheneSizeLike, GrapheneBox, GrapheneBoxLike, _GrapheneBox, GrapheneEuler, GrapheneEulerLike, _GrapheneEuler, GrapheneFrustum, GrapheneFrustumLike, _GrapheneFrustum, GrapheneMatrix, GrapheneMatrixLike, _GrapheneMatrix, GraphenePlane, GraphenePlaneLike, _GraphenePlane, GraphenePoint, GraphenePointLike, _GraphenePoint, GraphenePoint3D, GraphenePoint3DLike, _GraphenePoint3D, GrapheneQuad, GrapheneQuadLike, _GrapheneQuad, GrapheneQuaternion, GrapheneQuaternionLike, _GrapheneQuaternion, GrapheneRay, GrapheneRayLike, _GrapheneRay, GrapheneRect, GrapheneRectLike, _GrapheneRect, GrapheneSphere, GrapheneSphereLike, _GrapheneSphere, GrapheneTriangle, GrapheneTriangleLike, _GrapheneTriangle, GrapheneVec2, GrapheneVec2Like, _GrapheneVec2, GrapheneVec4, GrapheneVec4Like, _GrapheneVec4
