package GL.Skins is

type Veneer is abstract tagged null record;

type Skin is abstract tagged
      record
         null;
      end record;

type Skin_opaque_unlit_mono_color is new Skin with
      record
         Color : RGB_Color;
      end record;

type Veneer_opaque_lit_mono_color (max_Normals : gl.geometry.vertex_Id) is new Veneer with
      record
         Normals : gl.geometry.Normal_array (1 .. max_Normals);
      end record;

type Skin_opaque_lit_mono_color is new Skin with
      record
         Material : gl.materials.Material_type := materials.neutral_material;
      end record;

type Veneer_transparent_unlit_textured (num_Coordinates : gl.geometry.vertex_Id) is new Veneer with
      record
         texture_Coordinates : gl.textures.Coordinate_2D_array (1 .. num_Coordinates);
      end record;

type Skin_transparent_unlit_textured is new Skin with
      record
         Texture              : gl.Textures.Object;
         coordinate_Generator : gl.textures.p_coordinate_Generator;
      end record;

type Veneer_unlit_textured_vbo is new Veneer with
      record
         --texture_Coordinates : gl.Buffer.vertex_buffer_Object;
         texture_Coordinates : gl.Buffer.texture_coords.Object;
      end record;

type Skin_unlit_textured_vbo is new Skin with
      record
         Texture : gl.Textures.Object;
      end record;

type p_Veneer is access all Veneer'Class;

type p_Skin is access all Skin'Class;

type Skins is array (Positive range <>) of p_Skin;

type p_Veneer_transparent_unlit_textured is access all Veneer_transparent_unlit_textured'Class;

type p_Skin_transparent_unlit_textured is access all Skin_transparent_unlit_textured;

type p_Veneer_unlit_textured_vbo is access all Veneer_unlit_textured_vbo'Class;

type p_Skin_unlit_textured_vbo is access all Skin_unlit_textured_vbo;

null_Skins : constant Skins (1 .. 0) := (others => null);

green_Skin     : p_Skin := new gl.skins.Skin_opaque_unlit_mono_color'(color => (red   => 1.0,
                                                                                   green => 1.0,
                                                                                   blue  => 1.0));

lit_green_Skin : p_Skin := new gl.skins.Skin_opaque_lit_mono_color;

procedure destroy 
(
Self
: in out Veneer);

procedure free    
(
Self
: in out p_Veneer);

procedure enable 
(
Self
: in out Veneer)
is abstract;

procedure destroy 
(
Self
: in out Skin);

procedure free    
(
Self
: in out p_Skin);

function  new_Veneer 
(
Self
: in     Skin;
for_Geometry
: in gl.Geometry.Geometry'Class)
return p_Veneer   is abstract;

procedure enable         
(
Self
: in out Skin)
is abstract;

function  is_Transparent 
(
Self
: in     Skin)
return Boolean   is abstract;

function  new_Veneer     
(
Self
: in     Skin_opaque_unlit_mono_color;
for_Geometry
: in gl.Geometry.Geometry'Class)
return p_Veneer;

procedure enable         
(
Self
: in out Skin_opaque_unlit_mono_color);

function  is_Transparent 
(
Self
: in     Skin_opaque_unlit_mono_color)
return Boolean;

procedure enable 
(
Self
: in out Veneer_opaque_lit_mono_color);

function  new_Veneer 
(
Self
: in     Skin_opaque_lit_mono_color;
for_Geometry
: in gl.Geometry.Geometry'Class)
return p_Veneer;

procedure enable     
(
Self
: in out Skin_opaque_lit_mono_color);

function  is_Transparent 
(
Self
: in     Skin_opaque_lit_mono_color)
return Boolean;

procedure enable 
(
Self
: in out Veneer_transparent_unlit_textured);

procedure destroy 
(
Self
: in out Skin_transparent_unlit_textured);

function  new_Veneer     
(
Self
: in     Skin_transparent_unlit_textured;
for_Geometry
: in gl.Geometry.Geometry'Class)
return p_Veneer;

procedure enable         
(
Self
: in out Skin_transparent_unlit_textured);

function  is_Transparent 
(
Self
: in     Skin_transparent_unlit_textured)
return Boolean;

procedure enable 
(
Self
: in out Veneer_unlit_textured_vbo);

procedure destroy 
(
Self
: in out Skin_unlit_textured_vbo);

function  new_Veneer 
(
Self
: in     Skin_unlit_textured_vbo;
for_Geometry
: in gl.Geometry.Geometry'Class)
return p_Veneer;

procedure enable     
(
Self
: in out Skin_unlit_textured_vbo);

function  is_Transparent 
(
Self
: in     Skin_unlit_textured_vbo)
return Boolean;