











open Compatibility;;
open Types;;
open Default;;
open Constants;;
open Exceptions;;
open Basic_types;;
open Font;;
open Fonts;;
open Colors;;
open Vrml_objects_pre;;
open Calc_3D;;
open Vrml_objects_post;;
open Positionables;;
open Geometrics;;
open Geometric_properties;;
open Map;;
open Complex_geometrics;;
open Map_complex;;
open Lights;;
open Map_light;;
open Sound;;
open Frame_manipulations;;
open Specials;;
open World;;
open Translate;;
open Animations;;
open Traject;;



(* compatibility.ml *)
let (power : float -> float -> float) = power ;;
let (lt_int : 'a -> 'a -> bool) = lt_int ;;
let (lt_float : 'a -> 'a -> bool) = lt_float ;;
let (le_float : 'a -> 'a -> bool) = le_float ;;
let (gt_int : 'a -> 'a -> bool) = gt_int ;;
let (gt_float : 'a -> 'a -> bool) = gt_float ;;
let (mult_float : float -> float -> float) = mult_float ;;
let (add_int : int -> int -> int) = add_int ;;
let (int_of_char : char -> int) = int_of_char ;;
let (char_of_int : int -> char) = char_of_int ;;
let (space_char : char) = space_char ;;
let (lf_char : char) = lf_char ;;
let (char_0 : char) = char_0 ;;
let (comma_char : char) = comma_char ;;
let (open_par_char : char) = open_par_char ;;
let (close_par_char : char) = close_par_char ;;
let (ascii_0 : int) = ascii_0 ;;
let (ascii_9 : int) = ascii_9 ;;
let (ascii_a : int) = ascii_a ;;
let (ascii_f : int) = ascii_f ;;
let (ascii_A : int) = ascii_A ;;
let (ascii_F : int) = ascii_F ;;
let (eq_string : string -> string -> bool) = eq_string ;;
let (string_length : string -> int) = string_length ;;
let (sub_string : string -> int -> int -> string) = sub_string ;;
let (map : ('a -> 'b) -> 'a list -> 'b list) = map ;;
let (map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list) = map2 ;;
let (nth_char : string -> int -> char) = nth_char ;;
let (set_nth_char : string -> int -> char -> unit) = set_nth_char ;;
let (create_string : int -> string) = create_string ;;
let (make_string : int -> char -> string) = make_string ;;
let (it_list : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a) = it_list ;;
let (list_it : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b) = list_it ;;
let (append : 'a list -> 'a list -> 'a list) = append ;;
let (list_length : 'a list -> int) = list_length ;;
let (int_of_float : float -> int) = int_of_float ;;
let (float_of_int : int -> float) = float_of_int ;;
let (rev : 'a list -> 'a list) = rev ;;
let (do_list : ('a -> 'b) -> 'a list -> unit) = do_list ;;
let (do_list2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> unit) = do_list2 ;;
type 'a vect = 'a Compatibility.vect
let (mem : 'a -> 'a list -> bool) = mem ;;
let (vect_of_list : 'a list -> 'a array) = vect_of_list ;;
let (make_vect : int -> 'a -> 'a array) = make_vect ;;
let (except : 'a list -> 'a -> 'a list) = except ;;
let (subtract : 'a list -> 'a list -> 'a list) = subtract ;;
let (assoc : 'a -> ('a * 'b) list -> 'b) = assoc ;;
let (index : 'a -> 'a list -> int) = index ;;
let (replace_string : string -> string -> int -> unit) = replace_string ;;
let (format_float : ('a, unit, string) format -> 'a) = format_float ;;
let (std_out : out_channel) = std_out ;;
let (assq : 'a -> ('a * 'b) list -> 'b) = assq ;;
let (combine : 'a list -> 'b list -> ('a * 'b) list) = combine ;;
let (hd : 'a list -> 'a) = hd ;;
let (tl : 'a list -> 'a list) = tl ;;
let (vect_length : 'a array -> int) = vect_length ;;
(* types.ml *)
type vect2D = Types.vect2D 
type vect3D = Types.vect3D 
type rotation = Types.rotation 

type color = Types.color 

type time = Types.time 

type frame = Types.frame = 
  { height: float * float;
    width: float * float;
    depth: float * float }
type clip = Types.clip = 
  { clip_loop: bool;
    clip_start_time: time;
    clip_stop_time: time;
    clip_urls: string list }

type fontStyle = Types.fontStyle =
  { family: string;
    horizontal: bool;
    justify: string list;
    language: string;
    left_to_right: bool;
    size: float;
    spacing: float;
    style: string;
    top_to_bottom: bool }

type image = Types.image =
  { image_width: int;
    image_height: int;
    image_components: int;
    image_pixels: int list }

type textureCoordinate = Types.textureCoordinate (*vect2D list*)

type movieTexture = Types.movieTexture =
  { movieTexture_speed: float; movieTexture_clip: clip } 

type textureType = Types.textureType =
  | ImageTexture of string list
  | MovieTexture of movieTexture
  | PixelTexture of image


type textureItem = Types.textureItem =
  { texture_repeatS: bool;
    texture_repeatT: bool;
    texture_type: textureType;
    texture_center: vect2D;
    texture_rotation: float;
    texture_scale: vect2D;
    texture_translation: vect2D }

type texture = Types.texture =
  | NoTexture | Texture of textureItem

type materialItem = Types.materialItem =
  { ambient_intensity: float;
    diffuse_color: color;
    emissive_color: color;
    shininess: float;
    specular_color: color;
    transparency: float }

type material = Types.material =
  | NoMaterial | Material of materialItem

type point = Types.point = 
  { point_color: color; point_coordinate: vect3D }

type pointSet = Types.pointSet (*point list*)

type line = Types.line = 
  { line_point1: vect3D; line_point2: vect3D; line_color: color }

type lineSet = Types.lineSet (*line list*)

type unlitGeometric = Types.unlitGeometric = 
   | LineSet of lineSet | PointSet of pointSet

type box = Types.box = 
  { box_size: vect3D }

type cone = Types.cone = 
  { cone_bottom_radius: float;
    cone_height: float;
    cone_side: bool;
    cone_bottom: bool }

type cylinder = Types.cylinder =
  { cylinder_bottom: bool;
    cylinder_height: float;
    cylinder_radius: float;
    cylinder_side: bool;
    cylinder_top: bool } 

type elevationGrid = Types.elevationGrid = 
  { grid_color: color list;
    grid_texture_coordinate: textureCoordinate;
    grid_height: float list;
    grid_ccw: bool;
    grid_color_per_vertex: bool;
    grid_solid: bool;
    grid_x_dimension: int;
    grid_x_spacing: float;
    grid_z_dimension: int;
    grid_z_spacing: float } 

type extrusion = Types.extrusion = 
  { extrusion_begin_cap: bool;
    extrusion_ccw: bool;
    extrusion_convex: bool;
    extrusion_cross_section: vect2D list;
    extrusion_end_cap: bool;
    extrusion_orientation: rotation list;
    extrusion_scale: vect2D list;
    extrusion_solid: bool;
    extrusion_spine: vect3D list }

type sphere = Types.sphere = 
  { sphere_radius: float }

type text = Types.text = 
  { content: string list;
    font_style: fontStyle;
    length: float list;
    max_extent: float } 

type face = Types.face (*vect3D list*)

type faceSet = Types.faceSet =
  { faceSet_faces: face list;
    faceSet_texture_coordinate: textureCoordinate;
    faceSet_ccw: bool;
    faceSet_convex: bool;
    faceSet_solid: bool;
    faceSet_texture_coordinate_index: int list }

type shape = Types.shape = 
  | Box of box
  | Cone of cone
  | Cylinder of cylinder
  | ElevationGrid of elevationGrid
  | Extrusion of extrusion
  | FaceSet of faceSet
  | Sphere of sphere
  | Text of text

type directionalLight = Types.directionalLight =
  { directionalLight_direction: vect3D }

type pointLight = Types.pointLight =
  { pointLight_attenuation: vect3D;
    pointLight_radius: float } 

type spotLight = Types.spotLight =
  { spotLight_attenuation: vect3D;
    spotLight_beam_width: float;
    spotLight_cut_off_angle: float;
    spotLight_direction: vect3D;
    spotLight_radius: float } 

type lightType = Types.lightType = 
  | DirectionalLight of directionalLight
  | PointLight of pointLight
  | SpotLight of spotLight 

type light = Types.light =
  { light_ambient_intensity: float;
    light_color: color;
    light_intensity: float;
    light_type: lightType }

type geometric = Types.geometric = 
  { shape: shape; material: material; texture: texture }

type viewPoint = Types.viewPoint  =
  { viewPoint_field_of_view: float;
    viewPoint_jump: bool;
    viewPoint_description: string;
    navigation_avatar_size: float list;
    navigation_headlight: bool;
    navigation_speed: float;
    navigation_type: string list;
    navigation_visibility_limit: float }

type sound = Types.sound =
  { sound_direction: vect3D;
    sound_intensity: float;
    sound_max_back: float;
    sound_max_front: float;
    sound_min_back: float;
    sound_min_front: float;
    sound_priority: float;
    sound_spatialize: bool;
    sound_description: string;
    sound_pitch: float;
    sound_clip: clip } 

type background = Types.background =
  { ground_angle: float list;
    ground_color: color list;
    back_url: string list;
    bottom_url: string list;
    front_url: string list;
    left_url: string list;
    right_url: string list;
    top_url: string list;
    sky_angle: float list;
    sky_color: color list }

type fog = Types.fog =
  { fog_color: color;
    fog_type: string;
    fog_visibility_range: float } 

type vrml_special = Types.vrml_special = 
  | Background of background | Fog of fog

type anchorItem = Types.anchorItem = 
  { anchor_description: string;
    anchor_parameters: string list;
    anchor_urls: string list }

type anchor = Types.anchor = 
  | NoAnchor | Anchor of anchorItem

type billboardItem = Types.billboardItem = 
  { axis_of_rotation: vect3D }

type billboard = Types.billboard = 
  | NoBillboard | Billboard of billboardItem

type collisionBox = Types.collisionBox = 
  { collide: bool; bbox_center: vect3D; bbox_size: vect3D }

type collision = Types.collision = 
  | NoCollision | Collision of collisionBox

type proximityBox = Types.proximityBox = 
  { proximity_center: vect3D; proximity_size: vect3D }

type vrml_object = Types.vrml_object =
  { objects: vrml_positionable list;
    children: vrml_object list;
    position: vect3D;
    rotation: rotation;
    scale: vect3D;
    frame: frame;
    unique: bool;
    anchor: anchor;
    billboard: billboard;
    collision: collision }
and  vrml_positionable = Types.vrml_positionable =
  | Geometric of geometric
  | UnlitGeometric of unlitGeometric
  | CollisionBox of collisionBox
  | Light of light
  | LOD of lod
  | Sound of sound
  | ViewPoint of viewPoint 
and lod = Types.lod = 
  { lod_levels: vrml_object list; lod_ranges: float list }

type changing = Types.changing = 
  | Translation of (float list * vect3D list)
  | Rotation of (float list * rotation list)
  | Scale of (float list * vect3D list)
  | ChangeColor 

type trigger = Types.trigger =
  | Instant of time
  | Click of vrml_object
  | Enter of (proximityBox * vrml_object)
  | Exit of (proximityBox * vrml_object)

type animation = Types.animation = 
  { target: vrml_object;
    start_trigger: trigger list;
    stop_trigger: trigger list;
    loop: bool;
    duration: float;
    memory: bool;
    movie: changing list } 

type vrml_world = Types.vrml_world = 
  { info: string list;
    title: string;
    tree: vrml_object;
    specials: vrml_special list;
    animations: animation list } 

(* default.ml *)
let (default_frame : frame) = default_frame ;;
let (default_clip : clip) = default_clip ;;
let (default_fontStyle : fontStyle) = default_fontStyle ;;
let (default_image : image) = default_image ;;
let (default_vrml_object : vrml_object) = default_vrml_object ;;
let (default_anchor : anchorItem) = default_anchor ;;
let (default_basic_anchor : anchor) = default_basic_anchor ;;
let (default_billboard : billboardItem) = default_billboard ;;
let (default_basic_billboard : billboard) = default_basic_billboard ;;
let (default_collisionBox : collisionBox) = default_collisionBox ;;
let (default_basic_collision : collision) = default_basic_collision ;;
let (default_material : materialItem) = default_material ;;
let (default_basic_material : material) = default_basic_material ;;
let (default_textureCoordinate : 'a list) = default_textureCoordinate ;;
let (default_basic_imageTexture : textureType) = default_basic_imageTexture ;;
let (default_movieTexture : movieTexture) = default_movieTexture ;;
let (default_basic_movieTexture : textureType) = default_basic_movieTexture ;;
let (default_basic_pixelTexture : textureType) = default_basic_pixelTexture ;;
let (default_basic_texture : textureType -> texture) = default_basic_texture ;;
let (default_texture : textureType -> textureItem) = default_texture ;;
let (default_textureItem : textureItem) = default_textureItem ;;
let (default_basic_geometric : shape -> vrml_positionable) = default_basic_geometric ;;
let (default_point : point) = default_point ;;
let (default_pointSet : 'a list) = default_pointSet ;;
let (default_basic_pointSet : unlitGeometric) = default_basic_pointSet ;;
let (default_line : line) = default_line ;;
let (default_lineSet : 'a list) = default_lineSet ;;
let (default_basic_lineSet : unlitGeometric) = default_basic_lineSet ;;
let (default_box : box) = default_box ;;
let (default_basic_box : shape) = default_basic_box ;;
let (default_cone : cone) = default_cone ;;
let (default_basic_cone : shape) = default_basic_cone ;;
let (default_cylinder : cylinder) = default_cylinder ;;
let (default_basic_cylinder : shape) = default_basic_cylinder ;;
let (default_elevationGrid : elevationGrid) = default_elevationGrid ;;
let (default_basic_elevationGrid : shape) = default_basic_elevationGrid ;;
let (default_extrusion : extrusion) = default_extrusion ;;
let (default_basic_extrusion : shape) = default_basic_extrusion ;;
let (default_sphere : sphere) = default_sphere ;;
let (default_basic_sphere : shape) = default_basic_sphere ;;
let (default_text : text) = default_text ;;
let (default_basic_text : shape) = default_basic_text ;;
let (default_face : 'a list) = default_face ;;
let (default_faceSet : faceSet) = default_faceSet ;;
let (default_directionalLight : directionalLight) = default_directionalLight ;;
let (default_basic_directionalLight : lightType) = default_basic_directionalLight ;;
let (default_pointLight : pointLight) = default_pointLight ;;
let (default_basic_pointLight : lightType) = default_basic_pointLight ;;
let (default_spotLight : spotLight) = default_spotLight ;;
let (default_basic_spotLight : lightType) = default_basic_spotLight ;;
let (default_basic_light : lightType -> vrml_positionable) = default_basic_light ;;
let (default_light : light) = default_light ;;
let (default_sound : sound) = default_sound ;;
let (default_basic_sound : vrml_positionable) = default_basic_sound ;;
let (default_lod : lod) = default_lod ;;
let (default_basic_lod : vrml_positionable) = default_basic_lod ;;
let (default_viewPoint : viewPoint) = default_viewPoint ;;
let (default_basic_viewPoint : vrml_positionable) = default_basic_viewPoint ;;
let (default_background : background) = default_background ;;
let (default_basic_background : vrml_special) = default_basic_background ;;
let (default_fog : fog) = default_fog ;;
let (default_basic_fog : vrml_special) = default_basic_fog ;;
let (default_vrml_world : vrml_world) = default_vrml_world ;;

(* constants.ml *)
let (pi : float) = pi ;;

(* exceptions.ml *)
let (test_color : color -> color) = test_color ;;
let (test_time : time -> time) = test_time ;;
let (test_speed : float -> float) = test_speed ;;
let (test_size : vect3D -> vect3D) = test_size ;;
let (test_proximity_size : vect3D -> vect3D) = test_proximity_size ;;
let (test_radius : float -> float) = test_radius ;;
let (test_height : float -> float) = test_height ;;
let (test_length : float -> float) = test_length ;;
let (test_max_extent : float -> float) = test_max_extent ;;
let (test_elevationGrid_dimension : int -> int) = test_elevationGrid_dimension ;;
let (test_elevationGrid_spacing : float -> float) = test_elevationGrid_spacing ;;
let (test_extrusion_scale : vect2D list -> vect2D list) = test_extrusion_scale ;;
let (test_material_ambient_intensity : float -> float) = test_material_ambient_intensity ;;
let (test_material_shininess : float -> float) = test_material_shininess ;;
let (test_material_transparency : float -> float) = test_material_transparency ;;
let (test_attenuation : vect3D -> vect3D) = test_attenuation ;;
let (test_cut_off_angle : float -> float) = test_cut_off_angle ;;
let (test_beam_width : float -> float) = test_beam_width ;;
let (test_light_intensity : float -> float) = test_light_intensity ;;
let (test_light_ambient_intensity : float -> float) = test_light_ambient_intensity ;;
let (test_field_of_view : float -> float) = test_field_of_view ;;
let (test_avatar_size : float -> float) = test_avatar_size ;;
let (test_visibility_limit : float -> float) = test_visibility_limit ;;
let (test_sound_min_or_max : float -> float) = test_sound_min_or_max ;;
let (test_sound_intensity : float -> float) = test_sound_intensity ;;
let (test_sound_priority : float -> float) = test_sound_priority ;;
let (test_pitch : float -> float) = test_pitch ;;
let (test_background_angle : float -> float) = test_background_angle ;;

(* basic_types.ml *)
let (new_vect2D : float -> float -> vect2D) = new_vect2D ;;
let (new_vect3D : float -> float -> float -> vect3D) = new_vect3D ;;
let (new_rotation : float -> float -> float -> float -> rotation) = new_rotation ;;
let (new_color : float -> float -> float -> color) = new_color ;;
let (new_time : time -> time) = new_time ;;
let (new_frame : float -> float -> float -> float -> float -> float -> frame) = new_frame ;;
let (new_point : color -> float -> float -> float -> point) = new_point ;;
let (setf_point_color : point -> color -> point) = setf_point_color ;;
let (setf_point_coordinate : point -> float -> float -> float -> point) = setf_point_coordinate ;;
let (new_line : color -> vect3D -> vect3D -> line) = new_line ;;
let (setf_line_point1 : line -> vect3D -> line) = setf_line_point1 ;;
let (setf_line_point2 : line -> vect3D -> line) = setf_line_point2 ;;
let (setf_line_color : line -> color -> line) = setf_line_color ;;
let (new_face : face -> face) = new_face ;;
let (new_complete_clip : bool -> time -> time -> string list -> clip) = new_complete_clip ;;
let (new_clip : time -> time -> string -> clip) = new_clip ;;
let (setf_clip_loop : clip -> bool -> clip) = setf_clip_loop ;;
let (setf_clip_start_time : clip -> time -> clip) = setf_clip_start_time ;;
let (setf_clip_stop_time : clip -> time -> clip) = setf_clip_stop_time ;;
let (setf_clip_urls : clip -> string list -> clip) = setf_clip_urls ;;
let (new_image : int -> int -> int -> int list -> image) = new_image ;;
let (setf_image_width : image -> int -> image) = setf_image_width ;;
let (setf_image_height : image -> int -> image) = setf_image_height ;;
let (setf_image_components : image -> int -> image) = setf_image_components ;;
let (setf_image_pixels : image -> int list -> image) = setf_image_pixels ;;
let (new_basic_collisionBox : bool -> vect3D -> vect3D -> collisionBox) = new_basic_collisionBox ;;

(* font.ml *)
let (new_complete_font : string -> bool -> string list -> string -> bool -> float -> float -> string -> bool -> fontStyle) = new_complete_font ;;
let (new_font : string -> float -> string -> fontStyle) = new_font ;;
let (setf_family : fontStyle -> string -> fontStyle) = setf_family ;;
let (setf_horizontal : fontStyle -> bool -> fontStyle) = setf_horizontal ;;
let (setf_justify : fontStyle -> string list -> fontStyle) = setf_justify ;;
let (setf_language : fontStyle -> string -> fontStyle) = setf_language ;;
let (setf_left_to_right : fontStyle -> bool -> fontStyle) = setf_left_to_right ;;
let (setf_size : fontStyle -> float -> fontStyle) = setf_size ;;
let (setf_spacing : fontStyle -> float -> fontStyle) = setf_spacing ;;
let (setf_style : fontStyle -> string -> fontStyle) = setf_style ;;
let (setf_top_to_bottom : fontStyle -> bool -> fontStyle) = setf_top_to_bottom ;;
let (serif : string) = serif ;;
let (sans_serif : string) = sans_serif ;;
let (typewriter : string) = typewriter ;;
let (plain : string) = plain ;;
let (bold : string) = bold ;;
let (italic : string) = italic ;;
let (bold_italic : string) = bold_italic ;;
let (set_font_family : fontStyle -> string -> fontStyle) = set_font_family ;;
let (set_font_size : fontStyle -> float -> fontStyle) = set_font_size ;;
let (set_font_style : fontStyle -> string -> fontStyle) = set_font_style ;;

(* fonts.ml *)
let (plain_serif : fontStyle) = plain_serif ;;
let (plain_sans_serif : fontStyle) = plain_sans_serif ;;
let (plain_typewriter : fontStyle) = plain_typewriter ;;
let (bold_serif : fontStyle) = bold_serif ;;
let (bold_sans_serif : fontStyle) = bold_sans_serif ;;
let (bold_typewriter : fontStyle) = bold_typewriter ;;
let (italic_serif : fontStyle) = italic_serif ;;
let (italic_sans_serif : fontStyle) = italic_sans_serif ;;
let (italic_typewriter : fontStyle) = italic_typewriter ;;
let (bold_italic_serif : fontStyle) = bold_italic_serif ;;
let (bold_italic_sans_serif : fontStyle) = bold_italic_sans_serif ;;
let (bold_italic_typewriter : fontStyle) = bold_italic_typewriter ;;
let (white : color) = white ;;
let (black : color) = black ;;
let (green : color) = green ;;
let (red : color) = red ;;
let (blue : color) = blue ;;
let (yellow : color) = yellow ;;
let (magenta : color) = magenta ;;
let (cyan : color) = cyan ;;
let (dark_gray : color) = dark_gray ;;
let (dark_blue : color) = dark_blue ;;
let (dark_cyan : color) = dark_cyan ;;
let (dark_magenta : color) = dark_magenta ;;
let (dark_red : color) = dark_red ;;
let (light_green : color) = light_green ;;

(* vrml_objects_pre.ml *)
let (new_referential : vrml_object) = new_referential ;;
let (new_vrml_object : vrml_positionable list -> vrml_object list -> vect3D -> rotation -> vect3D -> frame -> bool -> anchor -> billboard -> collision -> vrml_object) = new_vrml_object ;;
let (setf_objects : vrml_object -> vrml_positionable list -> vrml_object) = setf_objects ;;
let (set_objects : vrml_object -> vrml_positionable list -> vrml_object) = set_objects ;;
let (setf_children : vrml_object -> vrml_object list -> vrml_object) = setf_children ;;
let (set_children : vrml_object -> vrml_object list -> vrml_object) = set_children ;;
let (setf_position : vrml_object -> vect3D -> vrml_object) = setf_position ;;
let (setf_rotation : vrml_object -> rotation -> vrml_object) = setf_rotation ;;
let (setf_scale : vrml_object -> vect3D -> vrml_object) = setf_scale ;;
let (setf_frame : vrml_object -> frame -> vrml_object) = setf_frame ;;
let (set_frame : vrml_object -> frame -> vrml_object) = set_frame ;;
let (setf_unique : vrml_object -> bool -> vrml_object) = setf_unique ;;
let (set_unique : vrml_object -> bool -> vrml_object) = set_unique ;;
let (setf_anchor : vrml_object -> anchor -> vrml_object) = setf_anchor ;;
let (setf_billboard : vrml_object -> billboard -> vrml_object) = setf_billboard ;;
let (setf_collision : vrml_object -> collision -> vrml_object) = setf_collision ;;

(* calc_3D.ml *)
let (rescale_3Dvect : float * float * float -> float * float * float -> float * float * float) = rescale_3Dvect ;;
let (retranslate_3Dvect : float * float * float -> float * float * float -> float * float * float) = retranslate_3Dvect ;;
let (rotat_point : (float * float * float) * float -> float * float * float -> float * float * float) = rotat_point ;;
let (frame_to_cube : frame -> (float * float * float) list) = frame_to_cube ;;
let (translate_frame : frame -> float * float * float -> frame) = translate_frame ;;
let (extract : ('a -> 'b) -> 'a list -> 'b * 'b) = extract ;;
let (give_x : 'a * 'b * 'c -> 'a) = give_x ;;
let (give_y : 'a * 'b * 'c -> 'b) = give_y ;;
let (give_z : 'a * 'b * 'c -> 'c) = give_z ;;
(* let (identity : 'a -> 'a) = identity ;; *)
let (frame_to_frame : frame -> (float * float * float) * float -> float * float * float -> frame) = frame_to_frame ;;
let (build_frame : frame -> (float * float * float) * float -> float * float * float -> float * float * float -> frame -> frame) = build_frame ;;
let (resize_frame_with_child : vrml_object -> vrml_object -> vrml_object) = resize_frame_with_child ;;
let (nth : 'a list -> int -> 'a) = nth ;;
let (fill_frame : float list -> frame) = fill_frame ;;
let (inv : float -> float) = inv ;;
let (member : 'a -> 'a list -> bool) = member ;;
let (plane_list : 'a list list -> 'a list) = plane_list ;;
let (vertex_extract : 'a list -> 'a list -> 'a list) = vertex_extract ;;
let (extract_shape : 'a list -> ('a * 'a * 'a) list -> 'a list) = extract_shape ;;
let (resize_frame : frame -> (float * float * float) list -> frame) = resize_frame ;;
let (translate_point : float * float * float -> float * float * float -> float * float * float) = translate_point ;;
let (scale_point : float * float * float -> float * float * float -> float * float * float) = scale_point ;;
let (compute_point : (float * float * float) * float -> float * float * float -> float * float * float -> float * float * float -> float * float * float) = compute_point ;;
let (tridim_y : 'a -> 'b * 'c -> 'c * 'a * 'b) = tridim_y ;;
let (rotat_list_point : ((float * float * float) * float) list -> float * float * float -> float * float * float) = rotat_list_point ;;
let (extrusion_frame_make : extrusion -> frame) = extrusion_frame_make ;;
let (geometric_frame_construct : geometric -> frame) = geometric_frame_construct ;;
let (extract_from_list : ('a -> 'b list) -> 'a list -> 'b list) = extract_from_list ;;
let (unlitGeometric_vertex_construct : unlitGeometric -> vect3D list) = unlitGeometric_vertex_construct ;;
let (unlitGeometric_frame_construct : unlitGeometric -> frame) = unlitGeometric_frame_construct ;;
let (vrml_positionable_frame_construct : vrml_positionable -> frame) = vrml_positionable_frame_construct ;;
let (resize_frame_with_object : vrml_object -> vrml_positionable -> vrml_object) = resize_frame_with_object ;;
let (get_resize_frame : vrml_object -> frame) = get_resize_frame ;;

(* vrml_objects_post.ml *)
let (add_object : vrml_object -> vrml_positionable -> vrml_object) = add_object ;;
let (add_objects : vrml_object -> vrml_positionable list -> vrml_object) = add_objects ;;
let (add_child : vrml_object -> vrml_object -> vrml_object) = add_child ;;
let (add_children : vrml_object -> vrml_object list -> vrml_object) = add_children ;;
let (set_position : vrml_object -> float -> float -> float -> vrml_object) = set_position ;;
let (set_translation : vrml_object -> float -> float -> float -> vrml_object) = set_translation ;;
let (set_rotation : vrml_object -> float -> float -> float -> float -> vrml_object) = set_rotation ;;
let (set_scale : vrml_object -> float -> float -> float -> vrml_object) = set_scale ;;
let (translation : vrml_object -> float -> float -> float -> vrml_object) = translation ;;
let (rotation : vrml_object -> float -> vrml_object) = rotation ;;
let (add_rotation : vrml_object -> float -> float -> float -> float -> vrml_object) = add_rotation ;;
let (resize : vrml_object -> float -> float -> float -> vrml_object) = resize ;;
let (group : vrml_object list -> vrml_object) = group ;;
let (ungroup : vrml_object -> vrml_object list) = ungroup ;;
let (agregate_one : vrml_object -> vrml_object -> vrml_object) = agregate_one ;;
let (objects_from_list : vrml_object list -> vrml_positionable list) = objects_from_list ;;
let (children_from_list : vrml_object list -> vrml_object list) = children_from_list ;;
let (agregate : vrml_object list -> vrml_object -> vrml_object) = agregate ;;
let (new_basic_anchor : string -> string list -> string list -> anchor) = new_basic_anchor ;;
let (set_complete_anchor : vrml_object -> string -> string list -> string list -> vrml_object) = set_complete_anchor ;;
let (set_urls : vrml_object -> string list -> vrml_object) = set_urls ;;
let (set_url : vrml_object -> string -> vrml_object) = set_url ;;
let (add_url : vrml_object -> string -> vrml_object) = add_url ;;
let (new_basic_billboard : float -> float -> float -> billboard) = new_basic_billboard ;;
let (set_billboard : vrml_object -> float -> float -> float -> vrml_object) = set_billboard ;;
let (setf_collide : collisionBox -> bool -> collisionBox) = setf_collide ;;
let (setf_bbox : collisionBox -> vect3D -> vect3D -> collisionBox) = setf_bbox ;;
let (setf_collision_collide : collision -> bool -> collision) = setf_collision_collide ;;
let (setf_collision_bbox : collision -> vect3D -> vect3D -> collision) = setf_collision_bbox ;;
let (new_basic_collision : bool -> vect3D -> vect3D -> collision) = new_basic_collision ;;
let (set_collidable : vrml_object -> vrml_object) = set_collidable ;;
let (set_uncollidable : vrml_object -> vrml_object) = set_uncollidable ;;
let (set_collision : vrml_object -> vect3D -> vect3D -> vrml_object) = set_collision ;;

(* positionables.mlp *)
let (new_basic_collision_box : vect3D -> vect3D -> vrml_positionable) = new_basic_collision_box ;;
let (new_collision_box : vect3D -> vect3D -> vrml_object) = new_collision_box ;;
let (setf_collision_box_center : vrml_positionable -> vect3D -> vrml_positionable) = setf_collision_box_center ;;
let (setf_collision_box_size : vrml_positionable -> vect3D -> vrml_positionable) = setf_collision_box_size ;;
let (new_unlit_geometric_object : vrml_positionable -> vrml_object) = new_unlit_geometric_object ;;
let (new_basic_pointSet : pointSet -> vrml_positionable) = new_basic_pointSet ;;
let (new_pointSet : pointSet -> vrml_object) = new_pointSet ;;
let (add_basic_point : vrml_positionable -> point -> vrml_positionable) = add_basic_point ;;
let (new_basic_lineSet : lineSet -> vrml_positionable) = new_basic_lineSet ;;
let (new_lineSet : lineSet -> vrml_object) = new_lineSet ;;
let (add_basic_line : vrml_positionable -> line -> vrml_positionable) = add_basic_line ;;
let (new_basic_viewPoint : float -> bool -> string -> float list -> bool -> float -> string list -> float -> vrml_positionable) = new_basic_viewPoint ;;
let (new_complete_viewPoint : float -> bool -> string -> float list -> bool -> float -> string list -> float -> vrml_object) = new_complete_viewPoint ;;
let (new_viewPoint : string -> vrml_object) = new_viewPoint ;;
let (setf_viewPoint_field_of_view : vrml_positionable -> float -> vrml_positionable) = setf_viewPoint_field_of_view ;;
let (setf_viewPoint_jump : vrml_positionable -> bool -> vrml_positionable) = setf_viewPoint_jump ;;
let (setf_viewPoint_description : vrml_positionable -> string -> vrml_positionable) = setf_viewPoint_description ;;
let (setf_navigation_avatar_sizes : vrml_positionable -> float list -> vrml_positionable) = setf_navigation_avatar_sizes ;;
let (setf_navigation_headlight : vrml_positionable -> bool -> vrml_positionable) = setf_navigation_headlight ;;
let (setf_navigation_speed : vrml_positionable -> float -> vrml_positionable) = setf_navigation_speed ;;
let (setf_navigation_types : vrml_positionable -> string list -> vrml_positionable) = setf_navigation_types ;;
let (setf_navigation_visibility_limit : vrml_positionable -> float -> vrml_positionable) = setf_navigation_visibility_limit ;;
let (new_basic_lod : vrml_object list -> float list -> vrml_positionable) = new_basic_lod ;;
let (new_lod : vrml_object list -> float list -> vrml_object) = new_lod ;;
let (setf_lod_levels : vrml_positionable -> vrml_object list -> vrml_object) = setf_lod_levels ;;
let (setf_lod_ranges : vrml_positionable -> float list -> vrml_object) = setf_lod_ranges ;;
let (add_lod_level_at_range : vrml_positionable -> vrml_object -> float -> vrml_object) = add_lod_level_at_range ;;

(* geometrics.ml *)
let (new_basic_geometric : shape -> material -> texture -> vrml_positionable) = new_basic_geometric ;;
let (setf_shape : vrml_positionable -> shape -> vrml_positionable) = setf_shape ;;
let (setf_material : vrml_positionable -> material -> vrml_positionable) = setf_material ;;
let (setf_texture : vrml_positionable -> texture -> vrml_positionable) = setf_texture ;;
let (new_geometric_object : shape -> vrml_object) = new_geometric_object ;;
let (setf_shape_field : vrml_positionable -> (shape -> 'a -> shape) -> 'a -> vrml_positionable) = setf_shape_field ;;
let (new_basic_box : float -> float -> float -> shape) = new_basic_box ;;
let (new_basic_cone : float -> float -> bool -> bool -> shape) = new_basic_cone ;;
let (setf_basic_cone_radius : shape -> float -> shape) = setf_basic_cone_radius ;;
let (setf_basic_cone_height : shape -> float -> shape) = setf_basic_cone_height ;;
let (setf_basic_cone_side : shape -> bool -> shape) = setf_basic_cone_side ;;
let (setf_basic_cone_bottom : shape -> bool -> shape) = setf_basic_cone_bottom ;;
let (setf_cone_radius : vrml_positionable -> float -> vrml_positionable) = setf_cone_radius ;;
let (setf_cone_height : vrml_positionable -> float -> vrml_positionable) = setf_cone_height ;;
let (setf_cone_side : vrml_positionable -> bool -> vrml_positionable) = setf_cone_side ;;
let (setf_cone_bottom : vrml_positionable -> bool -> vrml_positionable) = setf_cone_bottom ;;
let (new_basic_cylinder : bool -> float -> float -> bool -> bool -> shape) = new_basic_cylinder ;;
let (setf_basic_cylinder_bottom : shape -> bool -> shape) = setf_basic_cylinder_bottom ;;
let (setf_basic_cylinder_height : shape -> float -> shape) = setf_basic_cylinder_height ;;
let (setf_basic_cylinder_radius : shape -> float -> shape) = setf_basic_cylinder_radius ;;
let (setf_basic_cylinder_side : shape -> bool -> shape) = setf_basic_cylinder_side ;;
let (setf_basic_cylinder_top : shape -> bool -> shape) = setf_basic_cylinder_top ;;
let (setf_cylinder_bottom : vrml_positionable -> bool -> vrml_positionable) = setf_cylinder_bottom ;;
let (setf_cylinder_height : vrml_positionable -> float -> vrml_positionable) = setf_cylinder_height ;;
let (setf_cylinder_radius : vrml_positionable -> float -> vrml_positionable) = setf_cylinder_radius ;;
let (setf_cylinder_side : vrml_positionable -> bool -> vrml_positionable) = setf_cylinder_side ;;
let (setf_cylinder_top : vrml_positionable -> bool -> vrml_positionable) = setf_cylinder_top ;;
let (new_basic_sphere : float -> shape) = new_basic_sphere ;;
let (new_basic_text : string list -> fontStyle -> float list -> float -> shape) = new_basic_text ;;
let (setf_basic_content : shape -> string list -> shape) = setf_basic_content ;;
let (setf_basic_font_style : shape -> fontStyle -> shape) = setf_basic_font_style ;;
let (setf_basic_length : shape -> float list -> shape) = setf_basic_length ;;
let (setf_basic_max_extent : shape -> float -> shape) = setf_basic_max_extent ;;
let (setf_text_content : vrml_positionable -> string list -> vrml_positionable) = setf_text_content ;;
let (setf_text_font : vrml_positionable -> fontStyle -> vrml_positionable) = setf_text_font ;;
let (setf_text_length : vrml_positionable -> float list -> vrml_positionable) = setf_text_length ;;
let (setf_text_max_extent : vrml_positionable -> float -> vrml_positionable) = setf_text_max_extent ;;
let (new_box : float -> float -> float -> vrml_object) = new_box ;;
let (new_complete_cone : float -> float -> bool -> bool -> vrml_object) = new_complete_cone ;;
let (new_cone : float -> float -> vrml_object) = new_cone ;;
let (new_complete_cylinder : float -> float -> bool -> bool -> bool -> vrml_object) = new_complete_cylinder ;;
let (new_cylinder : float -> float -> vrml_object) = new_cylinder ;;
let (new_cube : float -> vrml_object) = new_cube ;;
let (new_sphere : float -> vrml_object) = new_sphere ;;
let (new_complete_text : string list -> fontStyle -> float list -> float -> vrml_object) = new_complete_text ;;
let (new_text : string list -> vrml_object) = new_text ;;
let (new_text_with_font : string list -> fontStyle -> vrml_object) = new_text_with_font ;;

(* geometric_properties.ml *)
let (new_basic_material : float -> color -> color -> float -> color -> float -> material) = new_basic_material ;;
let (setf_basic_ambient_intensity : material -> float -> material) = setf_basic_ambient_intensity ;;
let (setf_basic_diffuse_color : material -> color -> material) = setf_basic_diffuse_color ;;
let (setf_basic_emissive_color : material -> color -> material) = setf_basic_emissive_color ;;
let (setf_basic_shininess : material -> float -> material) = setf_basic_shininess ;;
let (setf_basic_specular_color : material -> color -> material) = setf_basic_specular_color ;;
let (setf_basic_transparency : material -> float -> material) = setf_basic_transparency ;;
let (setf_material_property : vrml_positionable -> (material -> 'a -> material) -> 'a -> vrml_positionable) = setf_material_property ;;
let (setf_ambient_intensity : vrml_positionable -> float -> vrml_positionable) = setf_ambient_intensity ;;
let (setf_diffuse_color : vrml_positionable -> color -> vrml_positionable) = setf_diffuse_color ;;
let (setf_emissive_color : vrml_positionable -> color -> vrml_positionable) = setf_emissive_color ;;
let (setf_shininess : vrml_positionable -> float -> vrml_positionable) = setf_shininess ;;
let (setf_specular_color : vrml_positionable -> color -> vrml_positionable) = setf_specular_color ;;
let (setf_transparency : vrml_positionable -> float -> vrml_positionable) = setf_transparency ;;
let (new_basic_texture : textureType -> bool -> bool -> vect2D -> float -> vect2D -> vect2D -> texture) = new_basic_texture ;;
let (new_basic_imageTexture : string list -> textureType) = new_basic_imageTexture ;;
let (new_basic_movieTexture : float -> clip -> textureType) = new_basic_movieTexture ;;
let (new_basic_pixelTexture : image -> textureType) = new_basic_pixelTexture ;;
let (new_imageTexture : string list -> texture) = new_imageTexture ;;
let (new_pixelTexture : image -> texture) = new_pixelTexture ;;
let (new_complete_movieTexture : float -> clip -> texture) = new_complete_movieTexture ;;
let (new_movieTexture : clip -> texture) = new_movieTexture ;;
let (setf_basic_texture_repeatS : texture -> bool -> texture) = setf_basic_texture_repeatS ;;
let (setf_basic_texture_repeatT : texture -> bool -> texture) = setf_basic_texture_repeatT ;;
let (setf_basic_texture_type : texture -> textureType -> texture) = setf_basic_texture_type ;;
let (setf_basic_texture_center : texture -> vect2D -> texture) = setf_basic_texture_center ;;
let (setf_basic_texture_rotation : texture -> float -> texture) = setf_basic_texture_rotation ;;
let (setf_basic_texture_scale : texture -> vect2D -> texture) = setf_basic_texture_scale ;;
let (setf_basic_texture_translation : texture -> vect2D -> texture) = setf_basic_texture_translation ;;
let (setf_basic_imageTexture_urls : textureType -> string list -> textureType) = setf_basic_imageTexture_urls ;;
let (setf_basic_pixelTexture_image : textureType -> image -> textureType) = setf_basic_pixelTexture_image ;;
let (setf_basic_movieTexture_speed : textureType -> float -> textureType) = setf_basic_movieTexture_speed ;;
let (setf_basic_movieTexture_clip : textureType -> clip -> textureType) = setf_basic_movieTexture_clip ;;
let (setf_texture_property : vrml_positionable -> (texture -> 'a -> texture) -> 'a -> vrml_positionable) = setf_texture_property ;;
let (setf_texture_repeatS : vrml_positionable -> bool -> vrml_positionable) = setf_texture_repeatS ;;
let (setf_texture_repeatT : vrml_positionable -> bool -> vrml_positionable) = setf_texture_repeatT ;;
let (setf_texture_type : vrml_positionable -> textureType -> vrml_positionable) = setf_texture_type ;;
let (setf_texture_center : vrml_positionable -> vect2D -> vrml_positionable) = setf_texture_center ;;
let (setf_texture_rotation : vrml_positionable -> float -> vrml_positionable) = setf_texture_rotation ;;
let (setf_texture_scale : vrml_positionable -> vect2D -> vrml_positionable) = setf_texture_scale ;;
let (setf_texture_translation : vrml_positionable -> vect2D -> vrml_positionable) = setf_texture_translation ;;
let (setf_imageTexture_urls : vrml_positionable -> string list -> vrml_positionable) = setf_imageTexture_urls ;;
let (setf_pixelTexture_image : vrml_positionable -> image -> vrml_positionable) = setf_pixelTexture_image ;;
let (setf_movieTexture_speed : vrml_positionable -> float -> vrml_positionable) = setf_movieTexture_speed ;;
let (setf_movieTexture_clip : vrml_positionable -> clip -> vrml_positionable) = setf_movieTexture_clip ;;

(* map.ml *)
let (mapp : 'a list -> ('a -> 'b -> 'c) -> 'b -> 'c list) = mapp ;;
let (map_obj : vrml_object -> (vrml_positionable -> 'a -> vrml_positionable) -> 'a -> vrml_object) = map_obj ;;
let (map_all : vrml_object -> (vrml_positionable -> 'a -> vrml_positionable) -> 'a -> vrml_object) = map_all ;;
let (map_imageTexture_url : vrml_object -> string -> vrml_object) = map_imageTexture_url ;;
let (map_texture : vrml_object -> string -> vrml_object) = map_texture ;;
let (map_pixelTexture_image : vrml_object -> image -> vrml_object) = map_pixelTexture_image ;;
let (map_movieTexture_speed : vrml_object -> float -> vrml_object) = map_movieTexture_speed ;;
let (map_movieTexture_clip : vrml_object -> clip -> vrml_object) = map_movieTexture_clip ;;
let (map_diffuse_color : vrml_object -> color -> vrml_object) = map_diffuse_color ;;
let (map_color : vrml_object -> color -> vrml_object) = map_color ;;
let (map_all_color : vrml_object -> color -> vrml_object) = map_all_color ;;
let (map_all_imageTexture_urls : vrml_object -> string -> vrml_object) = map_all_imageTexture_urls ;;
let (map_all_texture : vrml_object -> string -> vrml_object) = map_all_texture ;;
let (map_all_pixelTexture_image : vrml_object -> image -> vrml_object) = map_all_pixelTexture_image ;;
let (map_all_movieTexture_clip : vrml_object -> clip -> vrml_object) = map_all_movieTexture_clip ;;
let (map_all_movieTexture_speed : vrml_object -> float -> vrml_object) = map_all_movieTexture_speed ;;

(* complex_geometric.ml *)
let (new_basic_elevationGrid : color list -> textureCoordinate -> float list -> bool -> bool -> bool -> int -> float -> int -> float -> shape) = new_basic_elevationGrid ;;
let (new_complete_elevationGrid : color list -> textureCoordinate -> float list -> bool -> bool -> bool -> int -> float -> int -> float -> vrml_object) = new_complete_elevationGrid ;;
let (new_elevationGrid : float list -> int -> int -> float -> float -> vrml_object) = new_elevationGrid ;;
let (setf_basic_grid_color : shape -> color list -> shape) = setf_basic_grid_color ;;
let (setf_basic_grid_texture_coordinate : shape -> textureCoordinate -> shape) = setf_basic_grid_texture_coordinate ;;
let (setf_basic_grid_height : shape -> float list -> shape) = setf_basic_grid_height ;;
let (setf_basic_grid_ccw : shape -> bool -> shape) = setf_basic_grid_ccw ;;
let (setf_basic_grid_color_per_vertex : shape -> bool -> shape) = setf_basic_grid_color_per_vertex ;;
let (setf_basic_grid_solid : shape -> bool -> shape) = setf_basic_grid_solid ;;
let (setf_basic_grid_x_dimension : shape -> int -> shape) = setf_basic_grid_x_dimension ;;
let (setf_basic_grid_x_spacing : shape -> float -> shape) = setf_basic_grid_x_spacing ;;
let (setf_basic_grid_z_dimension : shape -> int -> shape) = setf_basic_grid_z_dimension ;;
let (setf_basic_grid_z_spacing : shape -> float -> shape) = setf_basic_grid_z_spacing ;;
let (setf_elevationGrid_colors : vrml_positionable -> color list -> vrml_positionable) = setf_elevationGrid_colors ;;
let (setf_elevationGrid_texture_coordinate : vrml_positionable -> textureCoordinate -> vrml_positionable) = setf_elevationGrid_texture_coordinate ;;
let (setf_elevationGrid_height : vrml_positionable -> float list -> vrml_positionable) = setf_elevationGrid_height ;;
let (setf_elevationGrid_ccw : vrml_positionable -> bool -> vrml_positionable) = setf_elevationGrid_ccw ;;
let (setf_elevationGrid_color_per_vertex : vrml_positionable -> bool -> vrml_positionable) = setf_elevationGrid_color_per_vertex ;;
let (setf_elevationGrid_solid : vrml_positionable -> bool -> vrml_positionable) = setf_elevationGrid_solid ;;
let (setf_elevationGrid_x_dimension : vrml_positionable -> int -> vrml_positionable) = setf_elevationGrid_x_dimension ;;
let (setf_elevationGrid_x_spacing : vrml_positionable -> float -> vrml_positionable) = setf_elevationGrid_x_spacing ;;
let (setf_elevationGrid_z_dimension : vrml_positionable -> int -> vrml_positionable) = setf_elevationGrid_z_dimension ;;
let (setf_elevationGrid_z_spacing : vrml_positionable -> float -> vrml_positionable) = setf_elevationGrid_z_spacing ;;
let (new_basic_extrusion : bool -> bool -> bool -> vect2D list -> bool -> rotation list -> vect2D list -> bool -> vect3D list -> shape) = new_basic_extrusion ;;
let (new_complete_extrusion : bool -> bool -> bool -> vect2D list -> bool -> rotation list -> vect2D list -> bool -> vect3D list -> vrml_object) = new_complete_extrusion ;;
let (new_extrusion : vect2D list -> vect3D list -> rotation list -> vrml_object) = new_extrusion ;;
let (new_extrusion_with_scales : vect2D list -> vect3D list -> rotation list -> vect2D list -> vrml_object) = new_extrusion_with_scales ;;
let (setf_basic_extrusion_begin_cap : shape -> bool -> shape) = setf_basic_extrusion_begin_cap ;;
let (setf_basic_extrusion_ccw : shape -> bool -> shape) = setf_basic_extrusion_ccw ;;
let (setf_basic_extrusion_convex : shape -> bool -> shape) = setf_basic_extrusion_convex ;;
let (setf_basic_extrusion_cross_section : shape -> vect2D list -> shape) = setf_basic_extrusion_cross_section ;;
let (setf_basic_extrusion_end_cap : shape -> bool -> shape) = setf_basic_extrusion_end_cap ;;
let (setf_basic_extrusion_orientation : shape -> rotation list -> shape) = setf_basic_extrusion_orientation ;;
let (setf_basic_extrusion_scale : shape -> vect2D list -> shape) = setf_basic_extrusion_scale ;;
let (setf_basic_extrusion_solid : shape -> bool -> shape) = setf_basic_extrusion_solid ;;
let (setf_basic_extrusion_spine : shape -> vect3D list -> shape) = setf_basic_extrusion_spine ;;
let (setf_extrusion_begin_cap : vrml_positionable -> bool -> vrml_positionable) = setf_extrusion_begin_cap ;;
let (setf_extrusion_ccw : vrml_positionable -> bool -> vrml_positionable) = setf_extrusion_ccw ;;
let (setf_extrusion_convex : vrml_positionable -> bool -> vrml_positionable) = setf_extrusion_convex ;;
let (setf_extrusion_cross_section : vrml_positionable -> vect2D list -> vrml_positionable) = setf_extrusion_cross_section ;;
let (setf_extrusion_end_cap : vrml_positionable -> bool -> vrml_positionable) = setf_extrusion_end_cap ;;
let (setf_extrusion_orientation : vrml_positionable -> rotation list -> vrml_positionable) = setf_extrusion_orientation ;;
let (setf_extrusion_scale : vrml_positionable -> vect2D list -> vrml_positionable) = setf_extrusion_scale ;;
let (setf_extrusion_solid : vrml_positionable -> bool -> vrml_positionable) = setf_extrusion_solid ;;
let (setf_extrusion_spine : vrml_positionable -> vect3D list -> vrml_positionable) = setf_extrusion_spine ;;
let (new_basic_faceSet : face list -> textureCoordinate -> bool -> bool -> bool -> int list -> shape) = new_basic_faceSet ;;
let (new_complete_faceSet : face list -> textureCoordinate -> bool -> bool -> bool -> int list -> vrml_object) = new_complete_faceSet ;;
let (new_faceSet : face list -> vrml_object) = new_faceSet ;;
let (setf_basic_faceSet_faces : shape -> face list -> shape) = setf_basic_faceSet_faces ;;
let (setf_basic_faceSet_texture_coordinate : shape -> textureCoordinate -> shape) = setf_basic_faceSet_texture_coordinate ;;
let (setf_basic_faceSet_ccw : shape -> bool -> shape) = setf_basic_faceSet_ccw ;;
let (setf_basic_faceSet_convex : shape -> bool -> shape) = setf_basic_faceSet_convex ;;
let (setf_basic_faceSet_solid : shape -> bool -> shape) = setf_basic_faceSet_solid ;;
let (setf_basic_faceSet_texture_coordinate_index : shape -> int list -> shape) = setf_basic_faceSet_texture_coordinate_index ;;
let (setf_faceSet_faces : vrml_positionable -> face list -> vrml_positionable) = setf_faceSet_faces ;;
let (setf_faceSet_texture_coordinate : vrml_positionable -> textureCoordinate -> vrml_positionable) = setf_faceSet_texture_coordinate ;;
let (setf_faceSet_ccw : vrml_positionable -> bool -> vrml_positionable) = setf_faceSet_ccw ;;
let (setf_faceSet_convex : vrml_positionable -> bool -> vrml_positionable) = setf_faceSet_convex ;;
let (setf_faceSet_solid : vrml_positionable -> bool -> vrml_positionable) = setf_faceSet_solid ;;
let (setf_faceSet_texture_coordinate_index : vrml_positionable -> int list -> vrml_positionable) = setf_faceSet_texture_coordinate_index ;;

(* map_complex.ml *)
let (map_elevationGrid_colors : vrml_object -> color list -> vrml_object) = map_elevationGrid_colors ;;
let (map_elevationGrid_texture_coordinates : vrml_object -> textureCoordinate -> vrml_object) = map_elevationGrid_texture_coordinates ;;

(* lights.ml *)
let (new_basic_directionalLight : vect3D -> lightType) = new_basic_directionalLight ;;
let (setf_basic_directionalLight_direction : lightType -> vect3D -> lightType) = setf_basic_directionalLight_direction ;;
let (new_basic_pointLight : vect3D -> float -> lightType) = new_basic_pointLight ;;
let (setf_basic_pointLight_attenuation : lightType -> vect3D -> lightType) = setf_basic_pointLight_attenuation ;;
let (setf_basic_pointLight_radius : lightType -> float -> lightType) = setf_basic_pointLight_radius ;;
let (new_basic_spotLight : vect3D -> float -> float -> vect3D -> float -> lightType) = new_basic_spotLight ;;
let (setf_basic_spotLight_attenuation : lightType -> vect3D -> lightType) = setf_basic_spotLight_attenuation ;;
let (setf_basic_spotLight_beam_width : lightType -> float -> lightType) = setf_basic_spotLight_beam_width ;;
let (setf_basic_spotLight_cut_off_angle : lightType -> float -> lightType) = setf_basic_spotLight_cut_off_angle ;;
let (setf_basic_spotLight_direction : lightType -> vect3D -> lightType) = setf_basic_spotLight_direction ;;
let (setf_basic_spotLight_radius : lightType -> float -> lightType) = setf_basic_spotLight_radius ;;
let (new_basic_light : lightType -> color -> float -> float -> vrml_positionable) = new_basic_light ;;
let (setf_light_color : vrml_positionable -> color -> vrml_positionable) = setf_light_color ;;
let (setf_light_ambient_intensity : vrml_positionable -> float -> vrml_positionable) = setf_light_ambient_intensity ;;
let (setf_light_intensity : vrml_positionable -> float -> vrml_positionable) = setf_light_intensity ;;
let (setf_light_type : vrml_positionable -> lightType -> vrml_positionable) = setf_light_type ;;
let (setf_light_type_property : vrml_positionable -> (lightType -> 'a -> lightType) -> 'a -> vrml_positionable) = setf_light_type_property ;;
let (setf_directionalLight_direction : vrml_positionable -> vect3D -> vrml_positionable) = setf_directionalLight_direction ;;
let (setf_pointLight_attenuation : vrml_positionable -> vect3D -> vrml_positionable) = setf_pointLight_attenuation ;;
let (setf_pointLight_radius : vrml_positionable -> float -> vrml_positionable) = setf_pointLight_radius ;;
let (setf_spotLight_attenuation : vrml_positionable -> vect3D -> vrml_positionable) = setf_spotLight_attenuation ;;
let (setf_spotLight_beam_width : vrml_positionable -> float -> vrml_positionable) = setf_spotLight_beam_width ;;
let (setf_spotLight_cut_off_angle : vrml_positionable -> float -> vrml_positionable) = setf_spotLight_cut_off_angle ;;
let (setf_spotLight_direction : vrml_positionable -> vect3D -> vrml_positionable) = setf_spotLight_direction ;;
let (setf_spotLight_radius : vrml_positionable -> float -> vrml_positionable) = setf_spotLight_radius ;;
let (new_complete_directionalLight : color -> float -> float -> vect3D -> vrml_object) = new_complete_directionalLight ;;
let (new_directionalLight : color -> float -> vect3D -> vrml_object) = new_directionalLight ;;
let (new_complete_pointLight : color -> float -> float -> vect3D -> float -> vrml_object) = new_complete_pointLight ;;
let (new_pointLight : color -> float -> float -> vrml_object) = new_pointLight ;;
let (new_complete_spotLight : color -> float -> float -> vect3D -> float -> float -> vect3D -> float -> vrml_object) = new_complete_spotLight ;;
let (new_spotLight : color -> float -> vect3D -> float -> vrml_object) = new_spotLight ;;

(* map_light.ml *)
let (map_light_color : vrml_object -> color -> vrml_object) = map_light_color ;;
let (map_directionalLight_direction : vrml_object -> vect3D -> vrml_object) = map_directionalLight_direction ;;

(* sound.ml *)
let (new_basic_sound : vect3D -> float -> float -> float -> float -> float -> float -> bool -> string -> float -> clip -> vrml_positionable) = new_basic_sound ;;
let (new_complete_sound : vect3D -> float -> float -> float -> float -> float -> float -> bool -> string -> float -> clip -> vrml_object) = new_complete_sound ;;
let (new_sound : vect3D -> float -> clip -> vrml_object) = new_sound ;;
let (setf_sound_direction : vrml_positionable -> vect3D -> vrml_positionable) = setf_sound_direction ;;
let (setf_sound_intensity : vrml_positionable -> float -> vrml_positionable) = setf_sound_intensity ;;
let (setf_sound_max_back : vrml_positionable -> float -> vrml_positionable) = setf_sound_max_back ;;
let (setf_sound_max_front : vrml_positionable -> float -> vrml_positionable) = setf_sound_max_front ;;
let (setf_sound_min_back : vrml_positionable -> float -> vrml_positionable) = setf_sound_min_back ;;
let (setf_sound_min_front : vrml_positionable -> float -> vrml_positionable) = setf_sound_min_front ;;
let (setf_sound_priority : vrml_positionable -> float -> vrml_positionable) = setf_sound_priority ;;
let (setf_sound_spatialize : vrml_positionable -> bool -> vrml_positionable) = setf_sound_spatialize ;;
let (setf_sound_description : vrml_positionable -> string -> vrml_positionable) = setf_sound_description ;;
let (setf_sound_pitch : vrml_positionable -> float -> vrml_positionable) = setf_sound_pitch ;;
let (setf_sound_clip : vrml_positionable -> clip -> vrml_positionable) = setf_sound_clip ;;

(* frame_manipulations.ml *)
let (get_x1 : frame -> float) = get_x1 ;;
let (get_x2 : frame -> float) = get_x2 ;;
let (get_y1 : frame -> float) = get_y1 ;;
let (get_y2 : frame -> float) = get_y2 ;;
let (get_z1 : frame -> float) = get_z1 ;;
let (get_z2 : frame -> float) = get_z2 ;;
let (place_top : vrml_object -> vrml_object -> vrml_object) = place_top ;;
let (place_bottom : vrml_object -> vrml_object -> vrml_object) = place_bottom ;;
let (place_right : vrml_object -> vrml_object -> vrml_object) = place_right ;;
let (place_left : vrml_object -> vrml_object -> vrml_object) = place_left ;;
let (place_front : vrml_object -> vrml_object -> vrml_object) = place_front ;;
let (place_behind : vrml_object -> vrml_object -> vrml_object) = place_behind ;;
let (stick_top : vrml_object -> vrml_object -> vrml_object) = stick_top ;;
let (stick_bottom : vrml_object -> vrml_object -> vrml_object) = stick_bottom ;;
let (stick_right : vrml_object -> vrml_object -> vrml_object) = stick_right ;;
let (stick_left : vrml_object -> vrml_object -> vrml_object) = stick_left ;;
let (stick_front : vrml_object -> vrml_object -> vrml_object) = stick_front ;;
let (stick_behind : vrml_object -> vrml_object -> vrml_object) = stick_behind ;;

(* special.ml *)
let (new_basic_background : float list -> color list -> string list -> string list -> string list -> string list -> string list -> string list -> float list -> color list -> vrml_special) = new_basic_background ;;
let (new_complete_background : float list -> color list -> string list -> string list -> string list -> string list -> string list -> string list -> float list -> color list -> vrml_special) = new_complete_background ;;
let (new_background : string -> color -> vrml_special) = new_background ;;
let (setf_background_ground_angles : vrml_special -> float list -> vrml_special) = setf_background_ground_angles ;;
let (setf_background_ground_colors : vrml_special -> color list -> vrml_special) = setf_background_ground_colors ;;
let (setf_background_back_urls : vrml_special -> string list -> vrml_special) = setf_background_back_urls ;;
let (setf_background_bottom_urls : vrml_special -> string list -> vrml_special) = setf_background_bottom_urls ;;
let (setf_background_front_urls : vrml_special -> string list -> vrml_special) = setf_background_front_urls ;;
let (setf_background_left_urls : vrml_special -> string list -> vrml_special) = setf_background_left_urls ;;
let (setf_background_right_urls : vrml_special -> string list -> vrml_special) = setf_background_right_urls ;;
let (setf_background_top_urls : vrml_special -> string list -> vrml_special) = setf_background_top_urls ;;
let (setf_background_sky_angles : vrml_special -> float list -> vrml_special) = setf_background_sky_angles ;;
let (setf_background_sky_colors : vrml_special -> color list -> vrml_special) = setf_background_sky_colors ;;
let (new_basic_fog : color -> string -> float -> vrml_special) = new_basic_fog ;;
let (linear_fog : string) = linear_fog ;;
let (exponential_fog : string) = exponential_fog ;;
let (new_complete_fog : color -> string -> float -> vrml_special) = new_complete_fog ;;
let (new_linear_fog : color -> vrml_special) = new_linear_fog ;;
let (new_exponential_fog : color -> vrml_special) = new_exponential_fog ;;
let (setf_fog_color : vrml_special -> color -> vrml_special) = setf_fog_color ;;
let (setf_fog_type : vrml_special -> string -> vrml_special) = setf_fog_type ;;
let (setf_fog_visibility_range : vrml_special -> float -> vrml_special) = setf_fog_visibility_range ;;

(* world.ml *)
let (new_vrml_world : string list -> string -> vrml_object -> vrml_special list -> animation list -> vrml_world) = new_vrml_world ;;
let (set_info : vrml_world -> string list -> vrml_world) = set_info ;;
let (set_title : vrml_world -> string -> vrml_world) = set_title ;;
let (set_tree : vrml_world -> vrml_object -> vrml_world) = set_tree ;;
let (set_specials : vrml_world -> vrml_special list -> vrml_world) = set_specials ;;
let (add_special : vrml_world -> vrml_special -> vrml_world) = add_special ;;
let (set_animations : vrml_world -> animation list -> vrml_world) = set_animations ;;
let (add_animation : vrml_world -> animation -> vrml_world) = add_animation ;;

(* translate.ml *)
type dictionary = Translate.dictionary =
  { name: string; triggers: trigger list }


type table = Translate.table = 
  { trigger_table: (trigger * string) list;
    object_table: (vrml_object * dictionary) list }

let (dico : table ref) = dico ;;
let (object_equivalent : vrml_object -> vrml_object -> bool) = object_equivalent ;;
let (object_table_find : vrml_object -> dictionary) = object_table_find ;;
let (object_table_remove : vrml_object -> unit) = object_table_remove ;;
let (object_table_add : vrml_object -> dictionary -> unit) = object_table_add ;;
let (dico_clear : unit -> unit) = dico_clear ;;
let (trigger_equivalent : trigger -> trigger -> bool) = trigger_equivalent ;;
let (trigger_name : trigger -> string) = trigger_name ;;
let (new_trigger_name : trigger -> string -> unit) = new_trigger_name ;;
let (new_trigger : vrml_object -> trigger -> unit) = new_trigger ;;
let (new_object_name : vrml_object -> string -> unit) = new_object_name ;;
let (object_table_construct : vrml_world -> unit) = object_table_construct ;;
let (reset : unit -> unit) = reset ;;
let (gensym : unit -> string) = gensym ;;
let (spaced_float : float -> string) = spaced_float ;;
let (string_of_scalar : float -> string) = string_of_scalar ;;
let (quote : string -> string) = quote ;;
let (string_of_vect2D : float * float -> string) = string_of_vect2D ;;
let (vect2D_translate : float * float -> string) = vect2D_translate ;;
let (string_of_vect3D : float * float * float -> string) = string_of_vect3D ;;
let (vect3D_translate : float * float * float -> string) = vect3D_translate ;;
let (bool_translate : bool -> string) = bool_translate ;;
let (concapply : ('a -> string) -> 'a list -> string) = concapply ;;
let (rotation_translate : (float * float * float) * float -> string) = rotation_translate ;;
let (translate_list : ('a -> string) -> 'a list -> string) = translate_list ;;
let (rotation_list_translate : ((float * float * float) * float) list -> string) = rotation_list_translate ;;
let (vect3D_list_translate : (float * float * float) list -> string) = vect3D_list_translate ;;
let (point_color_list_translate : point list -> string) = point_color_list_translate ;;
let (index_translate : int list -> string) = index_translate ;;
let (scalar_list_translate : float list -> string) = scalar_list_translate ;;
let (point_coordinate_list_translate : point list -> string) = point_coordinate_list_translate ;;
let (vect2D_list_translate : (float * float) list -> string) = vect2D_list_translate ;;
let (string_list_translate : string list -> string) = string_list_translate ;;
let (url_translate : string list -> string) = url_translate ;;
let (compare : 'a -> 'a -> ('a -> string) -> string) = compare ;;
let (box_translate : float * float * float -> float * float * float -> string) = box_translate ;;
let (material_translate : material -> string) = material_translate ;;
let (common_texture_translate : textureItem -> string) = common_texture_translate ;;
let (hexa : int -> string) = hexa ;;
let (clip_translate : clip -> string) = clip_translate ;;
let (image_translate : image -> string) = image_translate ;;
let (color_translate : point list -> string) = color_translate ;;
let (coordinate_translate : point list -> string) = coordinate_translate ;;
let (texCoord_translate : (float * float) list -> string) = texCoord_translate ;;
let (pointSet_translate : point list -> string) = pointSet_translate ;;
let (close_index : int list -> int list) = close_index ;;
let (create_index : 'a -> 'a list -> int list -> 'a list * int list) = create_index ;;
let (multi_create_index : 'a list -> 'a list -> int list -> 'a list * int list) = multi_create_index ;;
let (lineSet_translate : line list -> string) = lineSet_translate ;;
let (unlitGeometric_translate : unlitGeometric -> string) = unlitGeometric_translate ;;
let (textureCoordinate_translate : (float * float) list -> string) = textureCoordinate_translate ;;
let (create_face_list_index : 'a list list -> 'a list * int list) = create_face_list_index ;;
let (faceSet_translate : faceSet -> string) = faceSet_translate ;;
let (elevationGrid_translate : elevationGrid -> string) = elevationGrid_translate ;;
let (extrusion_translate : extrusion -> string) = extrusion_translate ;;
let (pixelTexture_translate : textureItem -> string) = pixelTexture_translate ;;
let (movieTexture_translate : textureItem -> string) = movieTexture_translate ;;
let (imageTexture_translate : textureItem -> string) = imageTexture_translate ;;
let (texture_translate : texture -> string) = texture_translate ;;
let (font_style_translate : fontStyle -> string) = font_style_translate ;;
let (recenter_translation : shape -> float * float * float) = recenter_translation ;;
let (geometric_translate : shape -> string) = geometric_translate ;;
let (shape_translate : geometric -> string) = shape_translate ;;
let (sound_translate : sound -> string) = sound_translate ;;
let (light_translate : light -> string) = light_translate ;;
let (viewPoint_translate : viewPoint -> string) = viewPoint_translate ;;
let (proximityBox_translate : proximityBox -> string) = proximityBox_translate ;;
let (is_a_real_transform : vrml_object -> bool) = is_a_real_transform ;;
let (compute_proximity_name : string -> trigger -> trigger list -> string) = compute_proximity_name ;;
let (sensor_translate : string -> 'a -> vrml_object -> string) = sensor_translate ;;
let (collisionBox_translate : collisionBox -> string) = collisionBox_translate ;;
let (billboard_translate : string -> 'a -> vrml_object -> string) = billboard_translate ;;
let (collision_translate : string -> 'a -> vrml_object -> string) = collision_translate ;;
let (transform_translate : string -> 'a -> vrml_object -> string) = transform_translate ;;
let (vrml_object_translate : 'a -> vrml_object -> string) = vrml_object_translate ;;
let (anchor_translate : string -> 'a -> vrml_object -> string) = anchor_translate ;;
let (vrml_positionnable_translate : string -> vrml_object -> 'a -> vrml_positionable -> string) = vrml_positionnable_translate ;;
let (lod_translate : 'a -> lod -> string) = lod_translate ;;
let (real_vrml_object_translate : 'a -> vrml_object -> string) = real_vrml_object_translate ;;
let (timeSensor_translate : string -> float -> bool -> bool -> float -> float -> string) = timeSensor_translate ;;
let (instant_script : string) = instant_script ;;
let (memory_script : string) = memory_script ;;
let (script_translate : string -> string -> string) = script_translate ;;
let (new_route : 'a list ref -> 'a -> unit) = new_route ;;
let (new_routes : 'a list ref -> 'a list -> unit) = new_routes ;;
(*
let instant_route_translate : 'a -> string -> ('b, string) t -> 'b -> 'a * string) = ue instant_route_translate ;; 
let (start_instant_route : string -> ('a, string) t -> 'a -> string * string) = start_instant_route ;;
let (stop_instant_route : string -> ('a, string) t -> 'a -> string * string) = stop_instant_route ;;
*)
let (trigger_create : 'a -> (string * string) list ref -> trigger -> string) = trigger_create ;;
let (start_trigger_route_translate : 'a -> 'b -> string -> 'c -> trigger -> (string * string) list) = start_trigger_route_translate ;;
let (stop_trigger_route_translate : 'a -> 'b -> string -> animation -> trigger -> (string * string) list) = stop_trigger_route_translate ;;
let (start_trigger_translate : 'a -> (string * string) list ref -> string -> 'b -> trigger -> string) = start_trigger_translate ;;
let (stop_trigger_translate : 'a -> (string * string) list ref -> string -> animation -> trigger -> string) = stop_trigger_translate ;;
let (interpolator_translate : string -> string -> float list * 'a -> int -> ('a -> string) -> string) = interpolator_translate ;;
let (interpolator_route_translate : string -> string -> string -> string -> int -> (string * string) list) = interpolator_route_translate ;;
let (changing_route_translate : changing -> string -> string -> string -> int -> (string * string) list) = changing_route_translate ;;
let (changing_list_route_translate : changing list -> string -> string -> string -> int -> (string * string) list) = changing_list_route_translate ;;
let (interpolator_translate : string -> string -> float list * 'a -> int -> ('a -> string) -> string) = interpolator_translate ;;
let (changing_translate : changing -> string -> int -> string) = changing_translate ;;
let (changing_list_translate : changing list -> string -> int -> string) = changing_list_translate ;;
let (animation_translate : 'a -> (string * string) list ref -> animation -> string) = animation_translate ;;
let (routes_translate : (string * string) list ref -> string) = routes_translate ;;
let (moving_object_translate : animation list -> string) = moving_object_translate ;;
let (background_translate : background -> string) = background_translate ;;
let (fog_translate : fog -> string) = fog_translate ;;
let (vrml_special_translate : vrml_special -> string) = vrml_special_translate ;;
let (vrml_special_list_translate : vrml_special list -> string) = vrml_special_list_translate ;;
let (vrml_world_translate : vrml_world -> string) = vrml_world_translate ;;
let (test : vrml_world -> unit) = test ;;
let (vrml_translate_to : vrml_world -> string -> unit) = vrml_translate_to ;;

(* animations.ml *)
let (new_animation : vrml_object -> trigger list -> trigger list -> bool -> float -> bool -> changing list -> animation) = new_animation ;;
let (setf_animation_target : animation -> vrml_object -> animation) = setf_animation_target ;;
let (setf_animation_start_trigger : animation -> trigger list -> animation) = setf_animation_start_trigger ;;
let (setf_animation_stop_trigger : animation -> trigger list -> animation) = setf_animation_stop_trigger ;;
let (setf_animation_loop : animation -> bool -> animation) = setf_animation_loop ;;
let (setf_animation_duration : animation -> float -> animation) = setf_animation_duration ;;
let (setf_animation_memory : animation -> bool -> animation) = setf_animation_memory ;;
let (setf_animation_movie : animation -> changing list -> animation) = setf_animation_movie ;;

(* traject.ml *)
let (initialize_object : animation -> animation) = initialize_object ;;
let (compute_trajectory : (float -> 'a) -> int -> float list * 'a list) = compute_trajectory ;;
let (circle_y : float -> float -> float * float * float) = circle_y ;;
let (circle_z : float -> float -> float * float * float) = circle_z ;;
let (ellipse : float -> float -> float -> float * float * float) = ellipse ;;
let (new_extrusion_bis : vect2D list -> vect3D list -> rotation list -> vect2D list -> vrml_object) = new_extrusion_bis ;;
let (revolution_orientation : int -> int -> float -> (float * float * float) * float) = revolution_orientation ;;
let (compute_values : int -> (float -> 'a) -> 'a list) = compute_values ;;
let (compute_2DShape_y : int -> (float -> 'a * 'b * 'c) -> ('a * 'c) list) = compute_2DShape_y ;;
let (identity : 'a -> float * float * float) =  identity ;;
let (compute_revolution_extrusion : vect2D list -> float -> int -> vrml_object) = compute_revolution_extrusion ;;
let (couronne : vrml_object) = couronne ;;
let (couronne : vrml_object) = couronne ;;
let (mon_world : vrml_world) = mon_world ;;
