1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213 | -- part of OpenGLAda, (c) 2017 Felix Krause
-- released under the terms of the MIT license, see the file "COPYING"
with Interfaces.C.Pointers;
with GL.Low_Level;
private with GL.Low_Level.Enums;
with GL.Pixels;
package GL.Objects.Buffers is
pragma Preelaborate;
type Buffer_Usage is (Stream_Draw, Stream_Read, Stream_Copy,
Static_Draw, Static_Read, Static_Copy,
Dynamic_Draw, Dynamic_Read, Dynamic_Copy);
type Map_Bits is record
Read : Boolean := False;
Write : Boolean := False;
Invalidate_Range : Boolean := False;
Invalidate_Buffer : Boolean := False;
Flush_Explicit : Boolean := False;
Unsynchronized : Boolean := False;
Persistent : Boolean := False;
Coherent : Boolean := False;
Unused : Boolean := False;
end record;
pragma Convention (C, Map_Bits);
type Buffer_Target (<>) is tagged limited private;
type Buffer is new GL_Object with private;
type Transform_Buffer is new GL_Object with private;
procedure Bind (Target : Buffer_Target; Object : Buffer'Class);
procedure Bind_Transform_Feedback (Object : Transform_Buffer'Class);
procedure Bind_Buffer_Base (Target : Buffer_Target; Index : UInt;
Object : Buffer'Class);
function Current_Object (Target : Buffer_Target) return Buffer'Class;
generic
with package Pointers is new Interfaces.C.Pointers (<>);
procedure Load_To_Buffer (Target : Buffer_Target'Class;
Data : Pointers.Element_Array;
Usage : Buffer_Usage);
-- Use this instead of Load_To_Buffer when you don't want to copy any data
procedure Allocate (Target : Buffer_Target; Number_Of_Bytes : Long;
Usage : Buffer_Usage);
generic
with package Pointers is new Interfaces.C.Pointers (<>);
procedure Map (Target : Buffer_Target'Class; Access_Type : Access_Kind;
Pointer : out Pointers.Pointer);
generic
with package Pointers is new Interfaces.C.Pointers (<>);
procedure Map_Range (Target : Buffer_Target'Class;
Access_Type : Map_Bits;
Offset : Int;
Size : Types.Size;
Pointer : out Pointers.Pointer);
procedure Unmap (Target : Buffer_Target);
procedure Flush_Mapped_Buffer_Range (Target : Buffer_Target'Class;
Offset : Int; Size : Types.Size);
generic
with package Pointers is new Interfaces.C.Pointers (<>);
function Pointer (Target : Buffer_Target'Class) return Pointers.Pointer;
generic
with package Pointers is new Interfaces.C.Pointers (<>);
procedure Set_Sub_Data (Target : Buffer_Target'Class;
Offset : Types.Size;
Data : Pointers.Element_Array);
procedure Get_Sub_Data (Target : Buffer_Target'Class;
Offset : Types.Int;
Data : out Types.Single_Array);
function Access_Type (Target : Buffer_Target) return Access_Kind;
function Mapped (Target : Buffer_Target) return Boolean;
function Size (Target : Buffer_Target) return Size;
function Usage (Target : Buffer_Target) return Buffer_Usage;
-- Unlike the underlying glDrawElements, this function takes the offset as
-- number of elements (not bytes). The correct byte value is calculated in
-- this wrapper based on the given Index_Type.
procedure Draw_Elements (Mode : Connection_Mode; Count : Types.Size;
Index_Type : Unsigned_Numeric_Type;
Element_Offset : Natural := 0);
-- Draw_Elements_Instanced behaves identically to Draw_Elements except
-- that primcount instances of the set of elements are executed and the
-- value of the internal counter instanceID advances for each iteration.
-- instanceID is an internal 32-bit integer counter that may be read by
-- a vertex shader as gl_InstanceID.
procedure Draw_Elements_Instanced (Mode : Connection_Mode;
Count : UInt;
Index_Type : Unsigned_Numeric_Type;
Element_Offset : UInt := 0;
Instance_Count : UInt := 0);
-- Draw_Elements_Base_Vertex allows the indices in the element array
-- buffer to be interpreted relative to some base index. For example,
-- multiple versions of a model (say, frames of an animation) can be stored
-- in a single set of vertex buffers at different offsets within the buffer.
-- Draw_Elements_Base_Vertex can then be used to draw any frame of that
-- animation by simply specifying the first index that corresponds to that
-- frame. The same set of indices can be used to reference every frame.
procedure Draw_Elements_Base_Vertex (Mode : Connection_Mode;
Count : UInt;
Index_Type : Unsigned_Numeric_Type;
Element_Offset : UInt;
Base_Vertex : Int);
procedure Draw_Transform_Feedback (Mode : Connection_Mode;
Object : Transform_Buffer);
procedure Draw_Transform_Feedback_Stream (Mode : Connection_Mode;
Object : Transform_Buffer;
Stream : UInt);
procedure Invalidate_Data (Object : in out Buffer);
procedure Invalidate_Sub_Data (Object : in out Buffer;
Offset, Length : Long_Size);
type Texture_Buffer_Target is limited new Buffer_Target with private;
type Transform_Buffer_Target is limited new Buffer_Target with private;
procedure Allocate (Target : Texture_Buffer_Target;
Format : GL.Pixels.Internal_Format;
Object : Buffer'Class);
Array_Buffer : constant Buffer_Target;
Element_Array_Buffer : constant Buffer_Target;
Pixel_Pack_Buffer : constant Buffer_Target;
Pixel_Unpack_Buffer : constant Buffer_Target;
Uniform_Buffer : constant Buffer_Target;
Texture_Buffer : constant Texture_Buffer_Target;
Transform_Feedback_Buffer : constant Transform_Buffer_Target;
Copy_Read_Buffer : constant Buffer_Target;
Copy_Write_Buffer : constant Buffer_Target;
Draw_Indirect_Buffer : constant Buffer_Target;
Shader_Storage_Buffer : constant Buffer_Target;
Atomic_Counter_Buffer : constant Buffer_Target;
private
for Buffer_Usage use (Stream_Draw => 16#88E0#,
Stream_Read => 16#88E1#,
Stream_Copy => 16#88E2#,
Static_Draw => 16#88E4#,
Static_Read => 16#88E5#,
Static_Copy => 16#88E6#,
Dynamic_Draw => 16#88E8#,
Dynamic_Read => 16#88E9#,
Dynamic_Copy => 16#88EA#);
for Buffer_Usage'Size use Low_Level.Enum'Size;
for Map_Bits use record
Read at 0 range 0 .. 0;
Write at 0 range 1 .. 1;
Invalidate_Range at 0 range 2 .. 2;
Invalidate_Buffer at 0 range 3 .. 3;
Flush_Explicit at 0 range 4 .. 4;
Unsynchronized at 0 range 5 .. 5;
Persistent at 0 range 6 .. 6;
Coherent at 0 range 7 .. 7;
Unused at 0 range 8 .. 31;
end record;
for Map_Bits'Size use Low_Level.Bitfield'Size;
type Buffer_Target (Kind : Low_Level.Enums.Buffer_Kind) is
tagged limited null record;
type Texture_Buffer_Target is limited new Buffer_Target with null record;
type Transform_Buffer_Target is limited new Buffer_Target with null record;
type Buffer is new GL_Object with null record;
type Transform_Buffer is new GL_Object with null record;
overriding
procedure Internal_Create_Id (Object : Buffer; Id : out UInt);
overriding
procedure Internal_Create_Id (Object : Transform_Buffer; Id : out UInt);
overriding
procedure Internal_Release_Id (Object : Buffer; Id : UInt);
overriding
procedure Internal_Release_Id (Object : Transform_Buffer; Id : UInt);
Array_Buffer : constant Buffer_Target
:= Buffer_Target'(Kind => Low_Level.Enums.Array_Buffer);
Element_Array_Buffer : constant Buffer_Target
:= Buffer_Target'(Kind => Low_Level.Enums.Element_Array_Buffer);
Pixel_Pack_Buffer : constant Buffer_Target
:= Buffer_Target'(Kind => Low_Level.Enums.Pixel_Pack_Buffer);
Pixel_Unpack_Buffer : constant Buffer_Target
:= Buffer_Target'(Kind => Low_Level.Enums.Pixel_Unpack_Buffer);
Uniform_Buffer : constant Buffer_Target
:= Buffer_Target'(Kind => Low_Level.Enums.Uniform_Buffer);
Texture_Buffer : constant Texture_Buffer_Target
:= Texture_Buffer_Target'(Kind => Low_Level.Enums.Texture_Buffer);
Transform_Feedback_Buffer : constant Transform_Buffer_Target
:= Transform_Buffer_Target'(Kind => Low_Level.Enums.Transform_Feedback_Buffer);
Copy_Read_Buffer : constant Buffer_Target
:= Buffer_Target'(Kind => Low_Level.Enums.Copy_Read_Buffer);
Copy_Write_Buffer : constant Buffer_Target
:= Buffer_Target'(Kind => Low_Level.Enums.Copy_Write_Buffer);
Draw_Indirect_Buffer : constant Buffer_Target
:= Buffer_Target'(Kind => Low_Level.Enums.Draw_Indirect_Buffer);
Shader_Storage_Buffer : constant Buffer_Target
:= Buffer_Target'(Kind => Low_Level.Enums.Shader_Storage_Buffer);
Atomic_Counter_Buffer : constant Buffer_Target
:= Buffer_Target'(Kind => Low_Level.Enums.Atomic_Counter_Buffer);
end GL.Objects.Buffers;
|