sig
  module BInfo :
    sig
      type t
      val create :
        unit ->
        ('a -> Lit.Renderer.Private.BInfo.t) *
        (Lit.Renderer.Private.BInfo.t -> 'a option)
      val none : Lit.Renderer.Private.BInfo.t
    end
  module Buf :
    sig
      type usage =
          [ `Dynamic_copy
          | `Dynamic_draw
          | `Dynamic_read
          | `Static_copy
          | `Static_draw
          | `Static_read
          | `Stream_copy
          | `Stream_draw
          | `Stream_read ]
      val pp_usage : Format.formatter -> usage -> unit
      type ('a, 'b) init =
          [ `Cpu of Gg.Ba.scalar_type * int
          | `Float16 of (int, Bigarray.int16_unsigned_elt) Gg.bigarray
          | `Float32 of (float, Bigarray.float32_elt) Gg.bigarray
          | `Float64 of (float, Bigarray.float64_elt) Gg.bigarray
          | `Gpu of Gg.Ba.scalar_type * int
          | `Int16 of (int, Bigarray.int16_signed_elt) Gg.bigarray
          | `Int32 of (int32, Bigarray.int32_elt) Gg.bigarray
          | `Int64 of (int64, Bigarray.int64_elt) Gg.bigarray
          | `Int8 of (int, Bigarray.int8_signed_elt) Gg.bigarray
          | `UInt16 of (int, Bigarray.int16_unsigned_elt) Gg.bigarray
          | `UInt32 of (int32, Bigarray.int32_elt) Gg.bigarray
          | `UInt64 of (int64, Bigarray.int64_elt) Gg.bigarray
          | `UInt8 of (int, Bigarray.int8_unsigned_elt) Gg.bigarray ]
      type t = buf
      val create :
        ?cpu_autorelease:bool -> ?usage:usage -> ('a, 'b) init -> buf
      val usage : buf -> usage
      val scalar_type : buf -> Gg.Ba.scalar_type
      val pp : Format.formatter -> buf -> unit
      val gpu_count : buf -> int
      val gpu_exists : buf -> bool
      val gpu_upload : buf -> bool
      val set_gpu_upload : buf -> bool -> unit
      val sync_gpu_to_cpu : renderer -> buf -> unit
      val gpu_map :
        renderer ->
        [ `R | `RW | `W ] ->
        buf -> ('a, 'b) Gg.Ba.ba_scalar_type -> ('a, 'b) Gg.bigarray
      val gpu_unmap : renderer -> buf -> unit
      val cpu_count : buf -> int
      val cpu_exists : buf -> bool
      val cpu :
        buf -> ('a, 'b) Gg.Ba.ba_scalar_type -> ('a, 'b) Gg.bigarray option
      val cpu_buffer : buf -> Gg.buffer option
      val get_cpu :
        buf -> ('a, 'b) Gg.Ba.ba_scalar_type -> ('a, 'b) Gg.bigarray
      val get_cpu_buffer : buf -> Gg.buffer
      val set_cpu : buf -> ('a, 'b) Gg.bigarray option -> unit
      val set_cpu_buffer : buf -> Gg.buffer option -> unit
      val cpu_autorelease : buf -> bool
      val set_cpu_autorelease : buf -> bool -> unit
      val sync_cpu_to_gpu : renderer -> buf -> unit
      type bigarray_any =
          Ba : ('a, 'b) Gg.bigarray -> Lit.Renderer.Private.Buf.bigarray_any
      val create_bigarray_any :
        Gg.Ba.scalar_type -> int -> Lit.Renderer.Private.Buf.bigarray_any
      val gpu_byte_count : Lit.buf -> int
      val set_gpu_count : Lit.buf -> int -> unit
      val set_gpu_exists : Lit.buf -> bool -> unit
      val cpu_byte_count : Lit.buf -> int
      val cpu_p : Lit.buf -> Lit.Renderer.Private.Buf.bigarray_any option
      val set_cpu_p :
        Lit.buf -> Lit.Renderer.Private.Buf.bigarray_any -> unit
      val check_ba_scalar_type :
        Lit.buf -> ('a, 'b) Gg.Ba.ba_scalar_type -> unit
      val binfo : Lit.buf -> Lit.Renderer.Private.BInfo.t
      val set_binfo : Lit.buf -> Lit.Renderer.Private.BInfo.t -> unit
    end
  module Attr :
    sig
      type t = attr
      val create :
        ?normalize:bool ->
        ?stride:int -> ?first:int -> string -> dim:int -> Buf.t -> t
      val name : attr -> string
      val dim : attr -> int
      val buf : attr -> Buf.t
      val stride : attr -> int
      val first : attr -> int
      val normalize : attr -> bool
      val rename : attr -> string -> attr
      val pp : Format.formatter -> attr -> unit
      val vertex : string
      val normal : string
      val color : string
      val tex : string
      val texn : int -> string
    end
  module Prim :
    sig
      type kind =
          [ `Line_loop
          | `Line_strip
          | `Line_strip_adjacency
          | `Lines
          | `Lines_adjacency
          | `Points
          | `Triangle_fan
          | `Triangle_strip
          | `Triangle_strip_adjacency
          | `Triangles
          | `Triangles_adjacency ]
      val pp_kind : Format.formatter -> kind -> unit
      type t = prim
      val create :
        ?tr:Gg.M4.t ->
        ?name:string ->
        ?first:int -> ?count:int -> ?index:Buf.t -> kind -> attr list -> prim
      val kind : prim -> kind
      val name : prim -> string
      val index : prim -> Buf.t option
      val first : prim -> int
      val count : prim -> int option
      val count_now : prim -> int
      val tr : prim -> Gg.M4.t
      val pp : Format.formatter -> prim -> unit
      val attrs : prim -> attr list
      val iter : (attr -> unit) -> prim -> unit
      val fold : ('a -> attr -> 'a) -> 'a -> prim -> 'a
      val mem : prim -> string -> bool
      val find : prim -> string -> attr option
      val get : prim -> string -> attr
      val binfo : Lit.prim -> Lit.Renderer.Private.BInfo.t
      val set_binfo : Lit.prim -> Lit.Renderer.Private.BInfo.t -> unit
    end
  module Tex :
    sig
      type wrap = [ `Clamp_to_edge | `Mirrored_repeat | `Repeat ]
      val pp_wrap : Format.formatter -> wrap -> unit
      type mag_filter = [ `Linear | `Nearest ]
      val pp_mag_filter : Format.formatter -> mag_filter -> unit
      type min_filter =
          [ `Linear
          | `Linear_mipmap_linear
          | `Linear_mipmap_nearest
          | `Nearest
          | `Nearest_mipmap_linear
          | `Nearest_mipmap_nearest ]
      val pp_min_filter : Format.formatter -> min_filter -> unit
      type kind = [ `Buffer | `D1 | `D2 | `D2_ms | `D3 | `D3_ms ]
      val pp_kind : Format.formatter -> kind -> unit
      type sample_format =
          [ `D1 of Gg.Ba.scalar_type * bool
          | `D2 of Gg.Ba.scalar_type * bool
          | `D3 of Gg.Ba.scalar_type * bool
          | `D4 of Gg.Ba.scalar_type * bool
          | `Depth of [ `Float32 | `UInt16 | `UInt24 ]
          | `Depth_stencil of [ `Float32_UInt8 | `UInt24_UInt8 ]
          | `SRGB of [ `UInt8 ]
          | `SRGBA of [ `UInt8 ]
          | `Stencil of [ `UInt8 ] ]
      val pp_sample_format : Format.formatter -> sample_format -> unit
      type init =
          [ `Buffer of sample_format * Buf.t
          | `D1 of sample_format * float * Buf.t option
          | `D2 of sample_format * Gg.size2 * Buf.t option
          | `D2_ms of sample_format * Gg.size2 * int * bool
          | `D3 of sample_format * Gg.size3 * Buf.t option
          | `D3_ms of sample_format * Gg.size3 * int * bool ]
      val pp_init : Format.formatter -> init -> unit
      val init_of_raster :
        ?buf:bool ->
        ?cpu_autorelease:bool ->
        ?usage:Buf.usage ->
        ?kind:kind ->
        ?sample_format:sample_format -> ?norm:bool -> Gg.raster -> init
      type t = tex
      val nil : tex
      val create :
        ?wrap_s:wrap ->
        ?wrap_t:wrap ->
        ?wrap_r:wrap ->
        ?mipmaps:bool ->
        ?min_filter:min_filter ->
        ?mag_filter:mag_filter -> ?buf_autorelease:bool -> init -> tex
      val sample_format : tex -> sample_format
      val kind : tex -> kind
      val size2 : tex -> Gg.size2
      val size3 : tex -> Gg.size3
      val buf : tex -> Buf.t option
      val set_buf : tex -> Buf.t option -> unit
      val buf_autorelease : tex -> bool
      val set_buf_autorelease : tex -> bool -> unit
      val gpu_update : tex -> bool
      val set_gpu_update : tex -> bool -> unit
      val wrap_s : tex -> wrap
      val wrap_t : tex -> wrap
      val wrap_r : tex -> wrap
      val mipmaps : tex -> bool
      val min_filter : tex -> min_filter
      val mag_filter : tex -> mag_filter
      val multisample : tex -> int * bool
      val pp : Format.formatter -> tex -> unit
      val binfo : Lit.tex -> Lit.Renderer.Private.BInfo.t
      val set_binfo : Lit.tex -> Lit.Renderer.Private.BInfo.t -> unit
    end
  module Prog :
    sig
      type loc = [ `Loc of string * int | `Unknown ]
      val pp_loc : Format.formatter -> loc -> unit
      type insert
      val insert : ?loc:loc -> string -> insert
      type lang = [ `GLSL of int | `GLSL_ES of int ]
      type shader_stage =
          [ `Compute
          | `Fragment
          | `Geometry
          | `Tess_control
          | `Tess_evaluation
          | `Vertex ]
      val pp_shader_stage : Format.formatter -> shader_stage -> unit
      type shader = Prog.shader
      val shader :
        ?lang:lang ->
        ?loc:loc -> ?inserts:insert list -> shader_stage -> string -> shader
      val stage : shader -> shader_stage
      val loc : shader -> loc
      val lang : shader -> lang option
      type source = string * (int * string) list
      val source : ?lang:lang -> shader -> source
      type t = prog
      val create : ?name:string -> ?uset:Uniform.set -> shader list -> prog
      val name : prog -> string
      val uniforms : prog -> Uniform.set
      val shaders : prog -> shader list
      val binfo : Lit.prog -> Lit.Renderer.Private.BInfo.t
      val set_binfo : Lit.prog -> Lit.Renderer.Private.BInfo.t -> unit
    end
  module Effect :
    sig
      type raster_face_cull = [ `Back | `Front ]
      type raster =
        Effect.raster = {
        raster_face_cull : raster_face_cull option;
        raster_multisample : bool;
      }
      val raster_default : raster
      type depth_test =
          [ `Always
          | `Equal
          | `Gequal
          | `Greater
          | `Lequal
          | `Less
          | `Nequal
          | `Never ]
      type depth =
        Effect.depth = {
        depth_test : depth_test option;
        depth_write : bool;
        depth_offset : float * float;
      }
      val depth_default : depth
      type blend_mul =
          [ `Cst
          | `Cst_a
          | `Dst
          | `Dst_a
          | `One
          | `One_minus_cst
          | `One_minus_cst_a
          | `One_minus_dst
          | `One_minus_dst_a
          | `One_minus_src
          | `One_minus_src1
          | `One_minus_src1_a
          | `One_minus_src_a
          | `Src
          | `Src1
          | `Src1_a
          | `Src_a
          | `Src_a_saturate
          | `Zero ]
      type blend_eq =
          [ `Add of blend_mul * blend_mul
          | `Max
          | `Min
          | `Rev_sub of blend_mul * blend_mul
          | `Sub of blend_mul * blend_mul ]
      val blend_eq_default : blend_eq
      type blend =
        Effect.blend = {
        blend : bool;
        blend_rgb : blend_eq;
        blend_a : blend_eq;
        blend_cst : Gg.color;
      }
      val blend_default : blend
      val blend_alpha : blend
      type t = effect
      val create :
        ?raster:raster ->
        ?depth:depth ->
        ?blend:blend -> ?uniforms:Uniform.set -> prog -> effect
      val prog : effect -> prog
      val uniforms : effect -> Uniform.set
      val get_uniform : effect -> 'a uniform -> Uniform.value_untyped
      val set_uniform : effect -> 'a uniform -> 'a -> unit
      val raster : effect -> raster
      val depth : effect -> depth
      val blend : effect -> blend
      val binfo : Lit.effect -> Lit.Renderer.Private.BInfo.t
      val set_binfo : Lit.effect -> Lit.Renderer.Private.BInfo.t -> unit
    end
  module Fbuf :
    sig
      module Rbuf :
        sig
          type t = Fbuf.Rbuf.t
          val create : ?multisample:int -> Gg.size2 -> Tex.sample_format -> t
          val multisample : t -> int option
          val size2 : t -> Gg.size2
          val sample_format : t -> Tex.sample_format
          val binfo : t -> Lit.Renderer.Private.BInfo.t
          val set_binfo : t -> Lit.Renderer.Private.BInfo.t -> unit
        end
      type clears = {
        clear_color : Gg.color option;
        clear_depth : float option;
        clear_stencil : int option;
      }
      val clears_default : clears
      type image =
          [ `Rbuf of Rbuf.t
          | `Tex of int * tex
          | `Tex_layer of int * int * tex ]
      type attachement =
          [ `Color of int * image
          | `Depth of image
          | `Depth_stencil of image
          | `Stencil of image ]
      type t = fbuf
      val default : fbuf
      val create : ?clears:clears -> attachement list -> fbuf
      val attachements : fbuf -> attachement list
      val is_multisample : fbuf -> bool
      val clears : fbuf -> clears
      val set_clears : fbuf -> clears -> unit
      val clear : renderer -> fbuf -> unit
      type status =
          [ `Complete
          | `Incomplete_attachement
          | `Incomplete_draw_buffer
          | `Incomplete_layer_targets
          | `Incomplete_missing_attachement
          | `Incomplete_multisample
          | `Incomplete_read_buffer
          | `Undefined
          | `Unknown of int
          | `Unsupported ]
      val pp_status : Format.formatter -> status -> unit
      val status : renderer -> fbuf -> status
      type read =
          [ `Color_b of int
          | `Color_g of int
          | `Color_r of int
          | `Color_rgb of int
          | `Color_rgba of int
          | `Depth
          | `Depth_stencil
          | `Stencil ]
      val read :
        ?first:int ->
        ?w_stride:int -> renderer -> fbuf -> read -> Gg.box2 -> buf -> unit
      type blit_buffer = [ `Color | `Depth | `Stencil ]
      type blit_filter = [ `Linear | `Nearest ]
      val blit :
        ?filter:blit_filter ->
        renderer ->
        blit_buffer list ->
        src:fbuf -> Gg.box2 -> dst:fbuf -> Gg.box2 -> unit
      val binfo : Lit.fbuf -> Lit.Renderer.Private.BInfo.t
      val set_binfo : Lit.fbuf -> Lit.Renderer.Private.BInfo.t -> unit
    end
  module Log :
    sig
      type compiler_msg =
          [ `Msg of string | `Msg_loc of string * Prog.loc * string ]
      val pp_compiler_msg : Format.formatter -> compiler_msg -> unit
      type compiler_msg_parser =
          string ->
          [ `Loc of string * int * int * string | `Unparsed of string ]
      val compiler_msg_parser_default : compiler_msg_parser
      val compiler_msg_parser_raw : compiler_msg_parser
      type msg =
          [ `Compiler of compiler_msg list
          | `Linker of string list
          | `Missing_attr of prim * string
          | `Msg of string
          | `Unsupported_shaders of prog * Prog.shader list ]
      val pp_msg : Format.formatter -> msg -> unit
      type level = [ `Debug | `Error ]
      type t = level -> msg -> unit
      val of_formatter : Format.formatter -> t
      val split_string : char -> string -> string list
      val lines : string -> string list
      val compiler_msg :
        string ->
        compiler_msg_parser ->
        (int * string) list -> [> `Compiler of compiler_msg list ]
    end
  module Cap :
    sig
      val parse_version : string -> (int * int * int) option
      type t = {
        c_shader_stages : Lit.Renderer.Private.Prog.shader_stage list;
        c_max_samples : int;
        c_max_tex_size : int;
        c_max_render_buffer_size : int;
        c_gl_version : Lit.Renderer.Cap.gl_version;
        c_glsl_version : Lit.Renderer.Cap.gl_version;
        c_gl_renderer : string;
        c_gl_vendor : string;
      }
    end
end