sig
module Float :
sig
type t = float
val e : float
val pi : float
val two_pi : float
val pi_div_2 : float
val pi_div_4 : float
val inv_pi : float
val max_sub_float : float
val min_sub_float : float
val max_frac_float : float
val max_int_arith : float
val deg_of_rad : float -> float
val rad_of_deg : float -> float
val wrap_angle : float -> float
val random : ?min:float -> len:float -> unit -> float
val srandom :
Random.State.t -> ?min:float -> len:float -> unit -> float
val mix : float -> float -> float -> float
val step : float -> float -> float
val smooth_step : float -> float -> float -> float
val fmax : float -> float -> float
val fmin : float -> float -> float
val clamp : min:float -> max:float -> float -> float
val remap :
x0:float -> x1:float -> y0:float -> y1:float -> float -> float
val round : float -> float
val int_of_round : float -> int
val round_dfrac : int -> float -> float
val round_dsig : int -> float -> float
val round_zero : eps:float -> float -> float
val chop : eps:float -> float -> float
val sign : float -> float
val sign_bit : float -> bool
val succ : float -> float
val pred : float -> float
val nan : int -> float
val nan_payload : float -> int
val is_zero : eps:float -> float -> bool
val is_nan : float -> bool
val is_inf : float -> bool
val is_int : float -> bool
val equal : float -> float -> bool
val equal_tol : eps:float -> float -> float -> bool
val compare : float -> float -> int
val compare_tol : eps:float -> float -> float -> int
val to_string : float -> string
val pp : Format.formatter -> float -> unit
end
type m2
type m3
type m4
type v2
type v3
type v4
module type V =
sig
type t
val dim : int
type m
val comp : int -> Gg.V.t -> float
val zero : Gg.V.t
val infinity : Gg.V.t
val neg_infinity : Gg.V.t
val basis : int -> Gg.V.t
val neg : Gg.V.t -> Gg.V.t
val add : Gg.V.t -> Gg.V.t -> Gg.V.t
val sub : Gg.V.t -> Gg.V.t -> Gg.V.t
val mul : Gg.V.t -> Gg.V.t -> Gg.V.t
val div : Gg.V.t -> Gg.V.t -> Gg.V.t
val smul : float -> Gg.V.t -> Gg.V.t
val half : Gg.V.t -> Gg.V.t
val dot : Gg.V.t -> Gg.V.t -> float
val norm : Gg.V.t -> float
val norm2 : Gg.V.t -> float
val unit : Gg.V.t -> Gg.V.t
val homogene : Gg.V.t -> Gg.V.t
val mix : Gg.V.t -> Gg.V.t -> float -> Gg.V.t
val ltr : Gg.V.m -> Gg.V.t -> Gg.V.t
val ( + ) : Gg.V.t -> Gg.V.t -> Gg.V.t
val ( - ) : Gg.V.t -> Gg.V.t -> Gg.V.t
val ( * ) : float -> Gg.V.t -> Gg.V.t
val ( / ) : Gg.V.t -> float -> Gg.V.t
val map : (float -> float) -> Gg.V.t -> Gg.V.t
val mapi : (int -> float -> float) -> Gg.V.t -> Gg.V.t
val fold : ('a -> float -> 'a) -> 'a -> Gg.V.t -> 'a
val foldi : ('a -> int -> float -> 'a) -> 'a -> Gg.V.t -> 'a
val iter : (float -> unit) -> Gg.V.t -> unit
val iteri : (int -> float -> unit) -> Gg.V.t -> unit
val for_all : (float -> bool) -> Gg.V.t -> bool
val exists : (float -> bool) -> Gg.V.t -> bool
val equal : Gg.V.t -> Gg.V.t -> bool
val equal_f : (float -> float -> bool) -> Gg.V.t -> Gg.V.t -> bool
val compare : Gg.V.t -> Gg.V.t -> int
val compare_f : (float -> float -> int) -> Gg.V.t -> Gg.V.t -> int
val to_string : Gg.V.t -> string
val pp : Format.formatter -> Gg.V.t -> unit
val pp_f :
(Format.formatter -> float -> unit) ->
Format.formatter -> Gg.V.t -> unit
end
module V2 :
sig
type t = Gg.v2
val dim : int
type m = Gg.m2
val v : float -> float -> Gg.v2
val comp : int -> Gg.v2 -> float
val x : Gg.v2 -> float
val y : Gg.v2 -> float
val ox : Gg.v2
val oy : Gg.v2
val zero : Gg.v2
val infinity : Gg.v2
val neg_infinity : Gg.v2
val basis : int -> Gg.v2
val of_tuple : float * float -> Gg.v2
val to_tuple : Gg.v2 -> float * float
val of_polar : Gg.v2 -> Gg.v2
val to_polar : Gg.v2 -> Gg.v2
val of_v3 : Gg.v3 -> Gg.v2
val of_v4 : Gg.v4 -> Gg.v2
val neg : Gg.v2 -> Gg.v2
val add : Gg.v2 -> Gg.v2 -> Gg.v2
val sub : Gg.v2 -> Gg.v2 -> Gg.v2
val mul : Gg.v2 -> Gg.v2 -> Gg.v2
val div : Gg.v2 -> Gg.v2 -> Gg.v2
val smul : float -> Gg.v2 -> Gg.v2
val half : Gg.v2 -> Gg.v2
val dot : Gg.v2 -> Gg.v2 -> float
val norm : Gg.v2 -> float
val norm2 : Gg.v2 -> float
val unit : Gg.v2 -> Gg.v2
val polar : float -> float -> Gg.v2
val angle : Gg.v2 -> float
val ortho : Gg.v2 -> Gg.v2
val homogene : Gg.v2 -> Gg.v2
val mix : Gg.v2 -> Gg.v2 -> float -> Gg.v2
val ltr : Gg.m2 -> Gg.v2 -> Gg.v2
val tr : Gg.m3 -> Gg.v2 -> Gg.v2
val ( + ) : Gg.v2 -> Gg.v2 -> Gg.v2
val ( - ) : Gg.v2 -> Gg.v2 -> Gg.v2
val ( * ) : float -> Gg.v2 -> Gg.v2
val ( / ) : Gg.v2 -> float -> Gg.v2
val map : (float -> float) -> Gg.v2 -> Gg.v2
val mapi : (int -> float -> float) -> Gg.v2 -> Gg.v2
val fold : ('a -> float -> 'a) -> 'a -> Gg.v2 -> 'a
val foldi : ('a -> int -> float -> 'a) -> 'a -> Gg.v2 -> 'a
val iter : (float -> unit) -> Gg.v2 -> unit
val iteri : (int -> float -> unit) -> Gg.v2 -> unit
val for_all : (float -> bool) -> Gg.v2 -> bool
val exists : (float -> bool) -> Gg.v2 -> bool
val equal : Gg.v2 -> Gg.v2 -> bool
val equal_f : (float -> float -> bool) -> Gg.v2 -> Gg.v2 -> bool
val compare : Gg.v2 -> Gg.v2 -> int
val compare_f : (float -> float -> int) -> Gg.v2 -> Gg.v2 -> int
val to_string : Gg.v2 -> string
val pp : Format.formatter -> Gg.v2 -> unit
val pp_f :
(Format.formatter -> float -> unit) ->
Format.formatter -> Gg.v2 -> unit
end
module V3 :
sig
type t = Gg.v3
val dim : int
type m = Gg.m3
val v : float -> float -> float -> Gg.v3
val comp : int -> Gg.v3 -> float
val x : Gg.v3 -> float
val y : Gg.v3 -> float
val z : Gg.v3 -> float
val ox : Gg.v3
val oy : Gg.v3
val oz : Gg.v3
val zero : Gg.v3
val infinity : Gg.v3
val neg_infinity : Gg.v3
val basis : int -> Gg.v3
val of_tuple : float * float * float -> Gg.v3
val to_tuple : Gg.v3 -> float * float * float
val of_spherical : Gg.v3 -> Gg.v3
val to_spherical : Gg.v3 -> Gg.v3
val of_v2 : Gg.v2 -> z:float -> Gg.v3
val of_v4 : Gg.v4 -> Gg.v3
val neg : Gg.v3 -> Gg.v3
val add : Gg.v3 -> Gg.v3 -> Gg.v3
val sub : Gg.v3 -> Gg.v3 -> Gg.v3
val mul : Gg.v3 -> Gg.v3 -> Gg.v3
val div : Gg.v3 -> Gg.v3 -> Gg.v3
val smul : float -> Gg.v3 -> Gg.v3
val half : Gg.v3 -> Gg.v3
val cross : Gg.v3 -> Gg.v3 -> Gg.v3
val dot : Gg.v3 -> Gg.v3 -> float
val norm : Gg.v3 -> float
val norm2 : Gg.v3 -> float
val unit : Gg.v3 -> Gg.v3
val spherical : float -> float -> float -> Gg.v3
val azimuth : Gg.v3 -> float
val zenith : Gg.v3 -> float
val homogene : Gg.v3 -> Gg.v3
val mix : Gg.v3 -> Gg.v3 -> float -> Gg.v3
val ltr : Gg.m3 -> Gg.v3 -> Gg.v3
val tr : Gg.m4 -> Gg.v3 -> Gg.v3
val ( + ) : Gg.v3 -> Gg.v3 -> Gg.v3
val ( - ) : Gg.v3 -> Gg.v3 -> Gg.v3
val ( * ) : float -> Gg.v3 -> Gg.v3
val ( / ) : Gg.v3 -> float -> Gg.v3
val map : (float -> float) -> Gg.v3 -> Gg.v3
val mapi : (int -> float -> float) -> Gg.v3 -> Gg.v3
val fold : ('a -> float -> 'a) -> 'a -> Gg.v3 -> 'a
val foldi : ('a -> int -> float -> 'a) -> 'a -> Gg.v3 -> 'a
val iter : (float -> unit) -> Gg.v3 -> unit
val iteri : (int -> float -> unit) -> Gg.v3 -> unit
val for_all : (float -> bool) -> Gg.v3 -> bool
val exists : (float -> bool) -> Gg.v3 -> bool
val equal : Gg.v3 -> Gg.v3 -> bool
val equal_f : (float -> float -> bool) -> Gg.v3 -> Gg.v3 -> bool
val compare : Gg.v3 -> Gg.v3 -> int
val compare_f : (float -> float -> int) -> Gg.v3 -> Gg.v3 -> int
val to_string : Gg.v3 -> string
val pp : Format.formatter -> Gg.v3 -> unit
val pp_f :
(Format.formatter -> float -> unit) ->
Format.formatter -> Gg.v3 -> unit
end
module V4 :
sig
type t = Gg.v4
val dim : int
type m = Gg.m4
val v : float -> float -> float -> float -> Gg.v4
val comp : int -> Gg.v4 -> float
val x : Gg.v4 -> float
val y : Gg.v4 -> float
val z : Gg.v4 -> float
val w : Gg.v4 -> float
val ox : Gg.v4
val oy : Gg.v4
val oz : Gg.v4
val ow : Gg.v4
val zero : Gg.v4
val infinity : Gg.v4
val neg_infinity : Gg.v4
val basis : int -> Gg.v4
val of_tuple : float * float * float * float -> Gg.v4
val to_tuple : Gg.v4 -> float * float * float * float
val of_v2 : Gg.v2 -> z:float -> w:float -> Gg.v4
val of_v3 : Gg.v3 -> w:float -> Gg.v4
val neg : Gg.v4 -> Gg.v4
val add : Gg.v4 -> Gg.v4 -> Gg.v4
val sub : Gg.v4 -> Gg.v4 -> Gg.v4
val mul : Gg.v4 -> Gg.v4 -> Gg.v4
val div : Gg.v4 -> Gg.v4 -> Gg.v4
val smul : float -> Gg.v4 -> Gg.v4
val half : Gg.v4 -> Gg.v4
val dot : Gg.v4 -> Gg.v4 -> float
val norm : Gg.v4 -> float
val norm2 : Gg.v4 -> float
val unit : Gg.v4 -> Gg.v4
val homogene : Gg.v4 -> Gg.v4
val mix : Gg.v4 -> Gg.v4 -> float -> Gg.v4
val ltr : Gg.m4 -> Gg.v4 -> Gg.v4
val ( + ) : Gg.v4 -> Gg.v4 -> Gg.v4
val ( - ) : Gg.v4 -> Gg.v4 -> Gg.v4
val ( * ) : float -> Gg.v4 -> Gg.v4
val ( / ) : Gg.v4 -> float -> Gg.v4
val map : (float -> float) -> Gg.v4 -> Gg.v4
val mapi : (int -> float -> float) -> Gg.v4 -> Gg.v4
val fold : ('a -> float -> 'a) -> 'a -> Gg.v4 -> 'a
val foldi : ('a -> int -> float -> 'a) -> 'a -> Gg.v4 -> 'a
val iter : (float -> unit) -> Gg.v4 -> unit
val iteri : (int -> float -> unit) -> Gg.v4 -> unit
val for_all : (float -> bool) -> Gg.v4 -> bool
val exists : (float -> bool) -> Gg.v4 -> bool
val equal : Gg.v4 -> Gg.v4 -> bool
val equal_f : (float -> float -> bool) -> Gg.v4 -> Gg.v4 -> bool
val compare : Gg.v4 -> Gg.v4 -> int
val compare_f : (float -> float -> int) -> Gg.v4 -> Gg.v4 -> int
val to_string : Gg.v4 -> string
val pp : Format.formatter -> Gg.v4 -> unit
val pp_f :
(Format.formatter -> float -> unit) ->
Format.formatter -> Gg.v4 -> unit
end
type p2 = Gg.v2
type p3 = Gg.v3
module type P =
sig
type t
val dim : int
type mh
val o : Gg.P.t
val mid : Gg.P.t -> Gg.P.t -> Gg.P.t
val tr : Gg.P.mh -> Gg.P.t -> Gg.P.t
end
module P2 :
sig
type t = Gg.p2
val dim : int
type mh = Gg.m3
val v : float -> float -> Gg.p2
val x : Gg.p2 -> float
val y : Gg.p2 -> float
val o : Gg.p2
val mid : Gg.p2 -> Gg.p2 -> Gg.p2
val tr : Gg.m3 -> Gg.p2 -> Gg.p2
end
module P3 :
sig
type t = Gg.p3
val dim : int
type mh = Gg.m4
val v : float -> float -> float -> Gg.p3
val x : Gg.p3 -> float
val y : Gg.p3 -> float
val z : Gg.p3 -> float
val o : Gg.p3
val mid : Gg.p3 -> Gg.p3 -> Gg.p3
val tr : Gg.m4 -> Gg.p3 -> Gg.p3
end
type quat = Gg.v4
module Quat :
sig
type t = Gg.quat
val v : float -> float -> float -> float -> Gg.quat
val zero : Gg.quat
val id : Gg.quat
val mul : Gg.quat -> Gg.quat -> Gg.quat
val conj : Gg.quat -> Gg.quat
val unit : Gg.quat -> Gg.quat
val inv : Gg.quat -> Gg.quat
val slerp : Gg.quat -> Gg.quat -> float -> Gg.quat
val squad :
Gg.quat -> Gg.quat -> Gg.quat -> Gg.quat -> float -> Gg.quat
val nlerp : Gg.quat -> Gg.quat -> float -> Gg.quat
val of_m3 : Gg.m3 -> Gg.quat
val of_m4 : Gg.m4 -> Gg.quat
val rot_map : Gg.v3 -> Gg.v3 -> Gg.quat
val rot_axis : Gg.v3 -> float -> Gg.quat
val rot_zyx : Gg.v3 -> Gg.quat
val to_rot_axis : Gg.quat -> Gg.v3 * float
val to_rot_zyx : Gg.quat -> Gg.v3
val apply3 : Gg.quat -> Gg.v3 -> Gg.v3
val apply4 : Gg.quat -> Gg.v4 -> Gg.v4
end
module type M =
sig
type t
val dim : int
type v
val el : int -> int -> Gg.M.t -> float
val row : int -> Gg.M.t -> Gg.M.v
val col : int -> Gg.M.t -> Gg.M.v
val zero : Gg.M.t
val id : Gg.M.t
val neg : Gg.M.t -> Gg.M.t
val add : Gg.M.t -> Gg.M.t -> Gg.M.t
val sub : Gg.M.t -> Gg.M.t -> Gg.M.t
val mul : Gg.M.t -> Gg.M.t -> Gg.M.t
val emul : Gg.M.t -> Gg.M.t -> Gg.M.t
val ediv : Gg.M.t -> Gg.M.t -> Gg.M.t
val smul : float -> Gg.M.t -> Gg.M.t
val transpose : Gg.M.t -> Gg.M.t
val trace : Gg.M.t -> float
val det : Gg.M.t -> float
val inv : Gg.M.t -> Gg.M.t
val map : (float -> float) -> Gg.M.t -> Gg.M.t
val mapi : (int -> int -> float -> float) -> Gg.M.t -> Gg.M.t
val fold : ('a -> float -> 'a) -> 'a -> Gg.M.t -> 'a
val foldi : ('a -> int -> int -> float -> 'a) -> 'a -> Gg.M.t -> 'a
val iter : (float -> unit) -> Gg.M.t -> unit
val iteri : (int -> int -> float -> unit) -> Gg.M.t -> unit
val for_all : (float -> bool) -> Gg.M.t -> bool
val exists : (float -> bool) -> Gg.M.t -> bool
val equal : Gg.M.t -> Gg.M.t -> bool
val equal_f : (float -> float -> bool) -> Gg.M.t -> Gg.M.t -> bool
val compare : Gg.M.t -> Gg.M.t -> int
val compare_f : (float -> float -> int) -> Gg.M.t -> Gg.M.t -> int
val to_string : Gg.M.t -> string
val pp : Format.formatter -> Gg.M.t -> unit
val pp_f :
(Format.formatter -> float -> unit) ->
Format.formatter -> Gg.M.t -> unit
end
module M2 :
sig
type t = Gg.m2
val dim : int
type v = Gg.v2
val v : float -> float -> float -> float -> Gg.m2
val of_rows : Gg.v2 -> Gg.v2 -> Gg.m2
val of_cols : Gg.v2 -> Gg.v2 -> Gg.m2
val el : int -> int -> Gg.m2 -> float
val row : int -> Gg.m2 -> Gg.v2
val col : int -> Gg.m2 -> Gg.v2
val zero : Gg.m2
val id : Gg.m2
val of_m3 : Gg.m3 -> Gg.m2
val of_m4 : Gg.m4 -> Gg.m2
val neg : Gg.m2 -> Gg.m2
val add : Gg.m2 -> Gg.m2 -> Gg.m2
val sub : Gg.m2 -> Gg.m2 -> Gg.m2
val mul : Gg.m2 -> Gg.m2 -> Gg.m2
val emul : Gg.m2 -> Gg.m2 -> Gg.m2
val ediv : Gg.m2 -> Gg.m2 -> Gg.m2
val smul : float -> Gg.m2 -> Gg.m2
val transpose : Gg.m2 -> Gg.m2
val trace : Gg.m2 -> float
val det : Gg.m2 -> float
val inv : Gg.m2 -> Gg.m2
val rot : float -> Gg.m2
val scale : Gg.v2 -> Gg.m2
val map : (float -> float) -> Gg.m2 -> Gg.m2
val mapi : (int -> int -> float -> float) -> Gg.m2 -> Gg.m2
val fold : ('a -> float -> 'a) -> 'a -> Gg.m2 -> 'a
val foldi : ('a -> int -> int -> float -> 'a) -> 'a -> Gg.m2 -> 'a
val iter : (float -> unit) -> Gg.m2 -> unit
val iteri : (int -> int -> float -> unit) -> Gg.m2 -> unit
val for_all : (float -> bool) -> Gg.m2 -> bool
val exists : (float -> bool) -> Gg.m2 -> bool
val equal : Gg.m2 -> Gg.m2 -> bool
val equal_f : (float -> float -> bool) -> Gg.m2 -> Gg.m2 -> bool
val compare : Gg.m2 -> Gg.m2 -> int
val compare_f : (float -> float -> int) -> Gg.m2 -> Gg.m2 -> int
val to_string : Gg.m2 -> string
val pp : Format.formatter -> Gg.m2 -> unit
val pp_f :
(Format.formatter -> float -> unit) ->
Format.formatter -> Gg.m2 -> unit
val e00 : Gg.m2 -> float
val e01 : Gg.m2 -> float
val e10 : Gg.m2 -> float
val e11 : Gg.m2 -> float
end
module M3 :
sig
type t = Gg.m3
val dim : int
type v = Gg.v3
val v :
float ->
float ->
float -> float -> float -> float -> float -> float -> float -> Gg.m3
val of_rows : Gg.v3 -> Gg.v3 -> Gg.v3 -> Gg.m3
val of_cols : Gg.v3 -> Gg.v3 -> Gg.v3 -> Gg.m3
val el : int -> int -> Gg.m3 -> float
val row : int -> Gg.m3 -> Gg.v3
val col : int -> Gg.m3 -> Gg.v3
val zero : Gg.m3
val id : Gg.m3
val of_m2_v2 : Gg.m2 -> Gg.v2 -> Gg.m3
val of_m4 : Gg.m4 -> Gg.m3
val of_quat : Gg.quat -> Gg.m3
val neg : Gg.m3 -> Gg.m3
val add : Gg.m3 -> Gg.m3 -> Gg.m3
val sub : Gg.m3 -> Gg.m3 -> Gg.m3
val mul : Gg.m3 -> Gg.m3 -> Gg.m3
val emul : Gg.m3 -> Gg.m3 -> Gg.m3
val ediv : Gg.m3 -> Gg.m3 -> Gg.m3
val smul : float -> Gg.m3 -> Gg.m3
val transpose : Gg.m3 -> Gg.m3
val trace : Gg.m3 -> float
val det : Gg.m3 -> float
val inv : Gg.m3 -> Gg.m3
val move : Gg.v2 -> Gg.m3
val rot : float -> Gg.m3
val scale2 : Gg.v2 -> Gg.m3
val rigid : move:Gg.v2 -> rot:float -> Gg.m3
val srigid : move:Gg.v2 -> rot:float -> scale:Gg.v2 -> Gg.m3
val rot_map : Gg.v3 -> Gg.v3 -> Gg.m3
val rot_axis : Gg.v3 -> float -> Gg.m3
val rot_zyx : Gg.v3 -> Gg.m3
val scale : Gg.v3 -> Gg.m3
val map : (float -> float) -> Gg.m3 -> Gg.m3
val mapi : (int -> int -> float -> float) -> Gg.m3 -> Gg.m3
val fold : ('a -> float -> 'a) -> 'a -> Gg.m3 -> 'a
val foldi : ('a -> int -> int -> float -> 'a) -> 'a -> Gg.m3 -> 'a
val iter : (float -> unit) -> Gg.m3 -> unit
val iteri : (int -> int -> float -> unit) -> Gg.m3 -> unit
val for_all : (float -> bool) -> Gg.m3 -> bool
val exists : (float -> bool) -> Gg.m3 -> bool
val equal : Gg.m3 -> Gg.m3 -> bool
val equal_f : (float -> float -> bool) -> Gg.m3 -> Gg.m3 -> bool
val compare : Gg.m3 -> Gg.m3 -> int
val compare_f : (float -> float -> int) -> Gg.m3 -> Gg.m3 -> int
val to_string : Gg.m3 -> string
val pp : Format.formatter -> Gg.m3 -> unit
val pp_f :
(Format.formatter -> float -> unit) ->
Format.formatter -> Gg.m3 -> unit
val e00 : Gg.m3 -> float
val e01 : Gg.m3 -> float
val e02 : Gg.m3 -> float
val e10 : Gg.m3 -> float
val e11 : Gg.m3 -> float
val e12 : Gg.m3 -> float
val e20 : Gg.m3 -> float
val e21 : Gg.m3 -> float
val e22 : Gg.m3 -> float
end
module M4 :
sig
type t = Gg.m4
val dim : int
type v = Gg.v4
val v :
float ->
float ->
float ->
float ->
float ->
float ->
float ->
float ->
float ->
float -> float -> float -> float -> float -> float -> float -> Gg.m4
val of_rows : Gg.v4 -> Gg.v4 -> Gg.v4 -> Gg.v4 -> Gg.m4
val of_cols : Gg.v4 -> Gg.v4 -> Gg.v4 -> Gg.v4 -> Gg.m4
val el : int -> int -> Gg.m4 -> float
val row : int -> Gg.m4 -> Gg.M4.v
val col : int -> Gg.m4 -> Gg.M4.v
val zero : Gg.m4
val id : Gg.m4
val of_m3_v3 : Gg.m3 -> Gg.v3 -> Gg.m4
val of_quat : Gg.quat -> Gg.m4
val neg : Gg.m4 -> Gg.m4
val add : Gg.m4 -> Gg.m4 -> Gg.m4
val sub : Gg.m4 -> Gg.m4 -> Gg.m4
val mul : Gg.m4 -> Gg.m4 -> Gg.m4
val emul : Gg.m4 -> Gg.m4 -> Gg.m4
val ediv : Gg.m4 -> Gg.m4 -> Gg.m4
val smul : float -> Gg.m4 -> Gg.m4
val transpose : Gg.m4 -> Gg.m4
val trace : Gg.m4 -> float
val det : Gg.m4 -> float
val inv : Gg.m4 -> Gg.m4
val move : Gg.v3 -> Gg.m4
val rot_map : Gg.v3 -> Gg.v3 -> Gg.m4
val rot_axis : Gg.v3 -> float -> Gg.m4
val rot_zyx : Gg.v3 -> Gg.m4
val scale3 : Gg.v3 -> Gg.m4
val rigid : move:Gg.v3 -> rot:Gg.v3 * float -> Gg.m4
val rigidq : move:Gg.v3 -> rot:Gg.quat -> Gg.m4
val srigid : move:Gg.v3 -> rot:Gg.v3 * float -> scale:Gg.v3 -> Gg.m4
val srigidq : move:Gg.v3 -> rot:Gg.quat -> scale:Gg.v3 -> Gg.m4
val ortho :
left:float ->
right:float ->
bottom:float -> top:float -> near:float -> far:float -> Gg.m4
val persp :
left:float ->
right:float ->
bottom:float -> top:float -> near:float -> far:float -> Gg.m4
val scale : Gg.v4 -> Gg.m4
val map : (float -> float) -> Gg.m4 -> Gg.m4
val mapi : (int -> int -> float -> float) -> Gg.m4 -> Gg.m4
val fold : ('a -> float -> 'a) -> 'a -> Gg.m4 -> 'a
val foldi : ('a -> int -> int -> float -> 'a) -> 'a -> Gg.m4 -> 'a
val iter : (float -> unit) -> Gg.m4 -> unit
val iteri : (int -> int -> float -> unit) -> Gg.m4 -> unit
val for_all : (float -> bool) -> Gg.m4 -> bool
val exists : (float -> bool) -> Gg.m4 -> bool
val equal : Gg.m4 -> Gg.m4 -> bool
val equal_f : (float -> float -> bool) -> Gg.m4 -> Gg.m4 -> bool
val compare : Gg.m4 -> Gg.m4 -> int
val compare_f : (float -> float -> int) -> Gg.m4 -> Gg.m4 -> int
val to_string : Gg.m4 -> string
val pp : Format.formatter -> Gg.m4 -> unit
val pp_f :
(Format.formatter -> float -> unit) ->
Format.formatter -> Gg.m4 -> unit
val e00 : Gg.m4 -> float
val e01 : Gg.m4 -> float
val e02 : Gg.m4 -> float
val e03 : Gg.m4 -> float
val e10 : Gg.m4 -> float
val e11 : Gg.m4 -> float
val e12 : Gg.m4 -> float
val e13 : Gg.m4 -> float
val e20 : Gg.m4 -> float
val e21 : Gg.m4 -> float
val e22 : Gg.m4 -> float
val e23 : Gg.m4 -> float
val e30 : Gg.m4 -> float
val e31 : Gg.m4 -> float
val e32 : Gg.m4 -> float
val e33 : Gg.m4 -> float
end
type size2 = Gg.v2
type size3 = Gg.v3
module type Size =
sig type t val dim : int val zero : Gg.Size.t val unit : Gg.Size.t end
module Size2 :
sig
type t = Gg.size2
val dim : int
val v : float -> float -> Gg.size2
val w : Gg.size2 -> float
val h : Gg.size2 -> float
val zero : Gg.size2
val unit : Gg.size2
end
module Size3 :
sig
type t = Gg.size3
val dim : int
val v : float -> float -> float -> Gg.size3
val w : Gg.size3 -> float
val h : Gg.size3 -> float
val d : Gg.size3 -> float
val zero : Gg.size3
val unit : Gg.size3
end
type box2
type box3
module type Box =
sig
type t
val dim : int
type v
type p
type size
type m
val v : Gg.Box.p -> Gg.Box.size -> Gg.Box.t
val v_mid : Gg.Box.p -> Gg.Box.size -> Gg.Box.t
val empty : Gg.Box.t
val o : Gg.Box.t -> Gg.Box.p
val size : Gg.Box.t -> Gg.Box.size
val zero : Gg.Box.t
val unit : Gg.Box.t
val of_pts : Gg.Box.p -> Gg.Box.p -> Gg.Box.t
val min : Gg.Box.t -> Gg.Box.p
val max : Gg.Box.t -> Gg.Box.p
val mid : Gg.Box.t -> Gg.Box.p
val area : Gg.Box.t -> float
val inter : Gg.Box.t -> Gg.Box.t -> Gg.Box.t
val union : Gg.Box.t -> Gg.Box.t -> Gg.Box.t
val inset : Gg.Box.v -> Gg.Box.t -> Gg.Box.t
val round : Gg.Box.t -> Gg.Box.t
val move : Gg.Box.v -> Gg.Box.t -> Gg.Box.t
val ltr : Gg.Box.m -> Gg.Box.t -> Gg.Box.t
val map_f : (float -> float) -> Gg.Box.t -> Gg.Box.t
val is_empty : Gg.Box.t -> bool
val is_pt : Gg.Box.t -> bool
val isects : Gg.Box.t -> Gg.Box.t -> bool
val subset : Gg.Box.t -> Gg.Box.t -> bool
val mem : Gg.Box.p -> Gg.Box.t -> bool
val equal : Gg.Box.t -> Gg.Box.t -> bool
val equal_f : (float -> float -> bool) -> Gg.Box.t -> Gg.Box.t -> bool
val compare : Gg.Box.t -> Gg.Box.t -> int
val compare_f : (float -> float -> int) -> Gg.Box.t -> Gg.Box.t -> int
val to_string : Gg.Box.t -> string
val pp : Format.formatter -> Gg.Box.t -> unit
val pp_f :
(Format.formatter -> float -> unit) ->
Format.formatter -> Gg.Box.t -> unit
end
module Box2 :
sig
type t = Gg.box2
val dim : int
type v = Gg.v2
type p = Gg.p2
type size = Gg.size2
type m = Gg.m2
val v : Gg.p2 -> Gg.size2 -> Gg.box2
val v_mid : Gg.p2 -> Gg.size2 -> Gg.Box2.t
val empty : Gg.box2
val o : Gg.box2 -> Gg.p2
val ox : Gg.box2 -> float
val oy : Gg.box2 -> float
val size : Gg.box2 -> Gg.Box2.size
val w : Gg.box2 -> float
val h : Gg.box2 -> float
val zero : Gg.box2
val unit : Gg.box2
val of_pts : Gg.p2 -> Gg.p2 -> Gg.box2
val min : Gg.box2 -> Gg.p2
val minx : Gg.box2 -> float
val miny : Gg.box2 -> float
val max : Gg.box2 -> Gg.p2
val maxx : Gg.box2 -> float
val maxy : Gg.box2 -> float
val mid : Gg.box2 -> Gg.p2
val midx : Gg.box2 -> float
val midy : Gg.box2 -> float
val bottom_left : Gg.box2 -> Gg.p2
val bottom_right : Gg.box2 -> Gg.p2
val top_left : Gg.box2 -> Gg.p2
val top_right : Gg.box2 -> Gg.p2
val area : Gg.box2 -> float
val inter : Gg.box2 -> Gg.box2 -> Gg.box2
val union : Gg.box2 -> Gg.box2 -> Gg.box2
val inset : Gg.v2 -> Gg.box2 -> Gg.box2
val round : Gg.box2 -> Gg.box2
val move : Gg.v2 -> Gg.box2 -> Gg.box2
val ltr : Gg.m2 -> Gg.box2 -> Gg.box2
val tr : Gg.m3 -> Gg.box2 -> Gg.box2
val map_f : (float -> float) -> Gg.box2 -> Gg.box2
val is_empty : Gg.box2 -> bool
val is_pt : Gg.box2 -> bool
val is_seg : Gg.box2 -> bool
val isects : Gg.box2 -> Gg.box2 -> bool
val subset : Gg.box2 -> Gg.box2 -> bool
val mem : Gg.p2 -> Gg.box2 -> bool
val equal : Gg.box2 -> Gg.box2 -> bool
val equal_f : (float -> float -> bool) -> Gg.box2 -> Gg.box2 -> bool
val compare : Gg.box2 -> Gg.box2 -> int
val compare_f : (float -> float -> int) -> Gg.box2 -> Gg.box2 -> int
val to_string : Gg.box2 -> string
val pp : Format.formatter -> Gg.box2 -> unit
val pp_f :
(Format.formatter -> float -> unit) ->
Format.formatter -> Gg.box2 -> unit
end
module Box3 :
sig
type t = Gg.box3
val dim : int
type v = Gg.v3
type p = Gg.p3
type size = Gg.size3
type m = Gg.m3
val v : Gg.p3 -> Gg.size3 -> Gg.box3
val v_mid : Gg.p3 -> Gg.size3 -> Gg.Box3.t
val empty : Gg.box3
val o : Gg.box3 -> Gg.p3
val ox : Gg.box3 -> float
val oy : Gg.box3 -> float
val oz : Gg.box3 -> float
val size : Gg.box3 -> Gg.size3
val w : Gg.box3 -> float
val h : Gg.box3 -> float
val d : Gg.box3 -> float
val zero : Gg.box3
val unit : Gg.box3
val of_pts : Gg.p3 -> Gg.p3 -> Gg.box3
val min : Gg.box3 -> Gg.p3
val minx : Gg.box3 -> float
val miny : Gg.box3 -> float
val minz : Gg.box3 -> float
val max : Gg.box3 -> Gg.p3
val maxx : Gg.box3 -> float
val maxy : Gg.box3 -> float
val maxz : Gg.box3 -> float
val mid : Gg.box3 -> Gg.p3
val midx : Gg.box3 -> float
val midy : Gg.box3 -> float
val midz : Gg.box3 -> float
val area : Gg.box3 -> float
val volume : Gg.box3 -> float
val inter : Gg.box3 -> Gg.box3 -> Gg.box3
val union : Gg.box3 -> Gg.box3 -> Gg.box3
val inset : Gg.v3 -> Gg.box3 -> Gg.box3
val round : Gg.box3 -> Gg.box3
val move : Gg.v3 -> Gg.box3 -> Gg.box3
val ltr : Gg.m3 -> Gg.box3 -> Gg.box3
val tr : Gg.m4 -> Gg.box3 -> Gg.box3
val map_f : (float -> float) -> Gg.box3 -> Gg.box3
val is_empty : Gg.box3 -> bool
val is_pt : Gg.box3 -> bool
val is_plane : Gg.box3 -> bool
val is_seg : Gg.box3 -> bool
val isects : Gg.box3 -> Gg.box3 -> bool
val subset : Gg.box3 -> Gg.box3 -> bool
val mem : Gg.p3 -> Gg.box3 -> bool
val equal : Gg.box3 -> Gg.box3 -> bool
val equal_f : (float -> float -> bool) -> Gg.box3 -> Gg.box3 -> bool
val compare : Gg.box3 -> Gg.box3 -> int
val compare_f : (float -> float -> int) -> Gg.box3 -> Gg.box3 -> int
val to_string : Gg.box3 -> string
val pp : Format.formatter -> Gg.box3 -> unit
val pp_f :
(Format.formatter -> float -> unit) ->
Format.formatter -> Gg.box3 -> unit
end
type color = Gg.v4
module Color :
sig
type t = Gg.color
type stops = (float * Gg.color) list
val v : float -> float -> float -> float -> Gg.color
val v_srgb : ?a:float -> float -> float -> float -> Gg.color
val v_srgbi : ?a:float -> int -> int -> int -> Gg.color
val r : Gg.color -> float
val g : Gg.color -> float
val b : Gg.color -> float
val a : Gg.color -> float
val void : Gg.color
val black : Gg.color
val gray : ?a:float -> float -> Gg.color
val white : Gg.color
val red : Gg.color
val green : Gg.color
val blue : Gg.color
val blend : Gg.color -> Gg.color -> Gg.color
val clamp : Gg.color -> Gg.color
val with_a : Gg.color -> float -> Gg.color
type srgb = Gg.v4
val of_srgb : Gg.Color.srgb -> Gg.color
val to_srgb : Gg.color -> Gg.Color.srgb
type luv = Gg.v4
val of_luv : Gg.Color.luv -> Gg.color
val to_luv : Gg.color -> Gg.Color.luv
type lch_uv = Gg.v4
val of_lch_uv : Gg.Color.lch_uv -> Gg.color
val to_lch_uv : Gg.color -> Gg.Color.lch_uv
type lab = Gg.v4
val of_lab : Gg.v4 -> Gg.color
val to_lab : Gg.color -> Gg.v4
type lch_ab = Gg.v4
val of_lch_ab : Gg.Color.lch_ab -> Gg.color
val to_lch_ab : Gg.color -> Gg.Color.lch_ab
type space =
[ `CLR2
| `CLR3
| `CLR4
| `CLR5
| `CLR6
| `CLR7
| `CLR8
| `CLR9
| `CLRA
| `CLRB
| `CLRC
| `CLRD
| `CLRE
| `CLRF
| `CMY
| `CMYK
| `Gray
| `HLS
| `HSV
| `Lab
| `Luv
| `RGB
| `XYZ
| `YCbr
| `Yxy ]
val space_dim : Gg.Color.space -> int
val pp_space : Format.formatter -> Gg.Color.space -> unit
type profile
val profile_of_icc : string -> Gg.Color.profile option
val profile_to_icc : Gg.Color.profile -> string
val profile_space : Gg.Color.profile -> Gg.Color.space
val profile_dim : Gg.Color.profile -> int
val p_gray_l : Gg.Color.profile
val p_rgb_l : Gg.Color.profile
end
type raster
module Raster :
sig
type scalar_type =
[ `Float16
| `Float32
| `Float64
| `Int16
| `Int32
| `Int64
| `Int8
| `UInt16
| `UInt32
| `UInt64
| `UInt8 ]
val scalar_type_byte_count : Gg.Raster.scalar_type -> int
val pp_scalar_type : Format.formatter -> Gg.Raster.scalar_type -> unit
type ('a, 'b) b_array = ('a, 'b, Bigarray.c_layout) Bigarray.Array1.t
type buffer =
[ `A_Float64 of float array
| `B_Float16 of
(int, Bigarray.int16_unsigned_elt) Gg.Raster.b_array
| `B_Float32 of (float, Bigarray.float32_elt) Gg.Raster.b_array
| `B_Float64 of (float, Bigarray.float64_elt) Gg.Raster.b_array
| `B_Int16 of (int, Bigarray.int16_signed_elt) Gg.Raster.b_array
| `B_Int32 of (int32, Bigarray.int32_elt) Gg.Raster.b_array
| `B_Int64 of (int64, Bigarray.int64_elt) Gg.Raster.b_array
| `B_Int8 of (int, Bigarray.int8_signed_elt) Gg.Raster.b_array
| `B_UInt16 of (int, Bigarray.int16_unsigned_elt) Gg.Raster.b_array
| `B_UInt32 of (int32, Bigarray.int32_elt) Gg.Raster.b_array
| `B_UInt64 of (int64, Bigarray.int64_elt) Gg.Raster.b_array
| `B_UInt8 of (int, Bigarray.int8_unsigned_elt) Gg.Raster.b_array
| `S_UInt8 of string ]
val buffer_scalar_type : Gg.Raster.buffer -> Gg.Raster.scalar_type
val pp_buffer : Format.formatter -> Gg.Raster.buffer -> unit
type sample_semantics =
[ `Color of Gg.Color.profile * bool | `Other of string * int ]
val rgb_l : Gg.Raster.sample_semantics
val rgba_l : Gg.Raster.sample_semantics
val gray_l : Gg.Raster.sample_semantics
val graya_l : Gg.Raster.sample_semantics
val pp_sample_semantics :
Format.formatter -> Gg.Raster.sample_semantics -> unit
type sample_pack =
[ `FourCC of string * Gg.Raster.scalar_type option
| `Other of string * Gg.Raster.scalar_type option
| `PU8888 ]
val pp_sample_pack : Format.formatter -> Gg.Raster.sample_pack -> unit
type sample_format
val sample_format_v :
?pack:Gg.Raster.sample_pack ->
Gg.Raster.sample_semantics ->
Gg.Raster.scalar_type -> Gg.Raster.sample_format
val sf_semantics :
Gg.Raster.sample_format -> Gg.Raster.sample_semantics
val sf_scalar_type : Gg.Raster.sample_format -> Gg.Raster.scalar_type
val sf_pack : Gg.Raster.sample_format -> Gg.Raster.sample_pack option
val sf_dim : Gg.Raster.sample_format -> int
val sf_scalar_count :
?first:int ->
?w_skip:int ->
?h_skip:int ->
w:int -> ?h:int -> ?d:int -> Gg.Raster.sample_format -> int
val pp_sample_format :
Format.formatter -> Gg.Raster.sample_format -> unit
type t = Gg.raster
val v :
?res:Gg.v3 ->
?first:int ->
?w_skip:int ->
?h_skip:int ->
w:int ->
?h:int ->
?d:int -> Gg.Raster.sample_format -> Gg.Raster.buffer -> Gg.Raster.t
val res : Gg.Raster.t -> Gg.v3 option
val first : Gg.Raster.t -> int
val w_skip : Gg.Raster.t -> int
val h_skip : Gg.Raster.t -> int
val w : Gg.Raster.t -> int
val h : Gg.Raster.t -> int
val d : Gg.Raster.t -> int
val sample_format : Gg.Raster.t -> Gg.Raster.sample_format
val buffer : Gg.Raster.t -> Gg.Raster.buffer
val dim : Gg.Raster.t -> int
val size2 : Gg.Raster.t -> Gg.size2
val size3 : Gg.Raster.t -> Gg.size3
val sub :
?x:int ->
?y:int ->
?z:int -> ?w:int -> ?h:int -> ?d:int -> Gg.Raster.t -> Gg.Raster.t
val pitches : Gg.Raster.t -> int * int * int
val equal : Gg.Raster.t -> Gg.Raster.t -> bool
val compare : Gg.Raster.t -> Gg.Raster.t -> int
val to_string : Gg.Raster.t -> string
val pp : Format.formatter -> Gg.Raster.t -> unit
end
end