Gawain: remove GL enum from vertex format API
[blender.git] / intern / gawain / src / vertex_format.c
1
2 // Gawain vertex format
3 //
4 // This code is part of the Gawain library, with modifications
5 // specific to integration with Blender.
6 //
7 // Copyright 2016 Mike Erwin
8 //
9 // This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of
10 // the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
11
12 #include "vertex_format.h"
13 #include <stdlib.h>
14 #include <string.h>
15
16 #define PACK_DEBUG 0
17
18 #if PACK_DEBUG
19   #include <stdio.h>
20 #endif
21
22 void VertexFormat_clear(VertexFormat* format)
23         {
24 #if TRUST_NO_ONE
25         memset(format, 0, sizeof(VertexFormat));
26 #else
27         format->attrib_ct = 0;
28         format->packed = false;
29         format->name_offset = 0;
30 #endif
31         }
32
33 void VertexFormat_copy(VertexFormat* dest, const VertexFormat* src)
34         {
35         // copy regular struct fields
36         memcpy(dest, src, sizeof(VertexFormat));
37         }
38
39 static GLenum convert_comp_type_to_gl(VertexCompType type)
40         {
41         static const GLenum table[] = {
42                 [COMP_I8] = GL_BYTE,
43                 [COMP_U8] = GL_UNSIGNED_BYTE,
44                 [COMP_I16] = GL_SHORT,
45                 [COMP_U16] = GL_UNSIGNED_SHORT,
46                 [COMP_I32] = GL_INT,
47                 [COMP_U32] = GL_UNSIGNED_INT,
48
49                 [COMP_F32] = GL_FLOAT,
50
51         #if USE_10_10_10
52                 [COMP_I10] = GL_INT_2_10_10_10_REV
53         #endif
54                 };
55         return table[type];
56         }
57
58 static unsigned comp_sz(VertexCompType type)
59         {
60 #if TRUST_NO_ONE
61         assert(type <= COMP_F32); // other types have irregular sizes (not bytes)
62 #endif
63
64         const GLubyte sizes[] = {1,1,2,2,4,4,4};
65         return sizes[type];
66         }
67
68 static unsigned attrib_sz(const Attrib *a)
69         {
70 #if USE_10_10_10
71         if (a->comp_type == COMP_I10)
72                 return 4; // always packed as 10_10_10_2
73 #endif
74
75         return a->comp_ct * comp_sz(a->comp_type);
76         }
77
78 static unsigned attrib_align(const Attrib *a)
79         {
80 #if USE_10_10_10
81         if (a->comp_type == COMP_I10)
82                 return 4; // always packed as 10_10_10_2
83 #endif
84
85         unsigned c = comp_sz(a->comp_type);
86         if (a->comp_ct == 3 && c <= 2)
87                 return 4 * c; // AMD HW can't fetch these well, so pad it out (other vendors too?)
88         else
89                 return c; // most fetches are ok if components are naturally aligned
90         }
91
92 unsigned vertex_buffer_size(const VertexFormat* format, unsigned vertex_ct)
93         {
94 #if TRUST_NO_ONE
95         assert(format->packed && format->stride > 0);
96 #endif
97
98         return format->stride * vertex_ct;
99         }
100
101 static const char* copy_attrib_name(VertexFormat* format, const char* name)
102         {
103         // strncpy does 110% of what we need; let's do exactly 100%
104         char* name_copy = format->names + format->name_offset;
105         unsigned available = VERTEX_ATTRIB_NAMES_BUFFER_LEN - format->name_offset;
106         bool terminated = false;
107
108         for (unsigned i = 0; i < available; ++i)
109                 {
110                 const char c = name[i];
111                 name_copy[i] = c;
112                 if (c == '\0')
113                         {
114                         terminated = true;
115                         format->name_offset += (i + 1);
116                         break;
117                         }
118                 }
119
120 #if TRUST_NO_ONE
121         assert(terminated);
122         assert(format->name_offset <= VERTEX_ATTRIB_NAMES_BUFFER_LEN);
123 #endif
124
125         return name_copy;
126         }
127
128 unsigned VertexFormat_add_attrib(VertexFormat* format, const char* name, VertexCompType comp_type, unsigned comp_ct, VertexFetchMode fetch_mode)
129         {
130 #if TRUST_NO_ONE
131         assert(format->attrib_ct < MAX_VERTEX_ATTRIBS); // there's room for more
132         assert(!format->packed); // packed means frozen/locked
133         assert(comp_ct >= 1 && comp_ct <= 4);
134         switch (comp_type)
135                 {
136                 case COMP_F32:
137                         // float type can only kept as float
138                         assert(fetch_mode == KEEP_FLOAT);
139                         break;
140  #if USE_10_10_10
141                 case COMP_I10:
142                         // 10_10_10 format intended for normals (xyz) or colors (rgb)
143                         // extra component packed.w can be manually set to { -2, -1, 0, 1 }
144                         assert(comp_ct == 3 || comp_ct == 4);
145                         assert(fetch_mode == NORMALIZE_INT_TO_FLOAT); // not strictly required, may relax later
146                         break;
147  #endif
148                 default:
149                         // integer types can be kept as int or converted/normalized to float
150                         assert(fetch_mode != KEEP_FLOAT);
151                 }
152 #endif
153
154         const unsigned attrib_id = format->attrib_ct++;
155         Attrib* attrib = format->attribs + attrib_id;
156
157         attrib->name = copy_attrib_name(format, name);
158         attrib->comp_type = comp_type;
159         attrib->gl_comp_type = convert_comp_type_to_gl(comp_type);
160 #if USE_10_10_10
161         attrib->comp_ct = (comp_type == COMP_I10) ? 4 : comp_ct; // system needs 10_10_10_2 to be 4 or BGRA
162 #else
163         attrib->comp_ct = comp_ct;
164 #endif
165         attrib->sz = attrib_sz(attrib);
166         attrib->offset = 0; // offsets & stride are calculated later (during pack)
167         attrib->fetch_mode = fetch_mode;
168
169         return attrib_id;
170         }
171
172 unsigned padding(unsigned offset, unsigned alignment)
173         {
174         const unsigned mod = offset % alignment;
175         return (mod == 0) ? 0 : (alignment - mod);
176         }
177
178 #if PACK_DEBUG
179 static void show_pack(unsigned a_idx, unsigned sz, unsigned pad)
180         {
181         const char c = 'A' + a_idx;
182         for (unsigned i = 0; i < pad; ++i)
183                 putchar('-');
184         for (unsigned i = 0; i < sz; ++i)
185                 putchar(c);
186         }
187 #endif
188
189 void VertexFormat_pack(VertexFormat* format)
190         {
191         // for now, attributes are packed in the order they were added,
192         // making sure each attrib is naturally aligned (add padding where necessary)
193
194         // later we can implement more efficient packing w/ reordering
195         // (keep attrib ID order, adjust their offsets to reorder in buffer)
196
197         // TODO:
198         // realloc just enough to hold the final combo string. And just enough to
199         // hold used attribs, not all 16.
200
201         Attrib* a0 = format->attribs + 0;
202         a0->offset = 0;
203         unsigned offset = a0->sz;
204
205 #if PACK_DEBUG
206         show_pack(0, a0->sz, 0);
207 #endif
208
209         for (unsigned a_idx = 1; a_idx < format->attrib_ct; ++a_idx)
210                 {
211                 Attrib* a = format->attribs + a_idx;
212                 unsigned mid_padding = padding(offset, attrib_align(a));
213                 offset += mid_padding;
214                 a->offset = offset;
215                 offset += a->sz;
216
217 #if PACK_DEBUG
218                 show_pack(a_idx, a->sz, mid_padding);
219 #endif
220                 }
221
222         unsigned end_padding = padding(offset, attrib_align(a0));
223
224 #if PACK_DEBUG
225         show_pack(0, 0, end_padding);
226         putchar('\n');
227 #endif
228
229         format->stride = offset + end_padding;
230         format->packed = true;
231         }
232
233
234 #if USE_10_10_10
235
236 // OpenGL ES packs in a different order as desktop GL but component conversion is the same.
237 // Of the code here, only struct PackedNormal needs to change.
238
239 #define SIGNED_INT_10_MAX  511
240 #define SIGNED_INT_10_MIN -512
241
242 static int clampi(int x, int min_allowed, int max_allowed)
243         {
244 #if TRUST_NO_ONE
245         assert(min_allowed <= max_allowed);
246 #endif
247
248         if (x < min_allowed)
249                 return min_allowed;
250         else if (x > max_allowed)
251                 return max_allowed;
252         else
253                 return x;
254         }
255
256 static int quantize(float x)
257         {
258         int qx = x * 511.0f;
259         return clampi(qx, SIGNED_INT_10_MIN, SIGNED_INT_10_MAX);
260         }
261
262 PackedNormal convert_i10_v3(const float data[3])
263         {
264         PackedNormal n = { .x = quantize(data[0]), .y = quantize(data[1]), .z = quantize(data[2]) };
265         return n;
266         }
267
268 #endif // USE_10_10_10