]> git.tdb.fi Git - libs/gl.git/blob - source/core/batch.cpp
Initial implementation of Vulkan backend
[libs/gl.git] / source / core / batch.cpp
1 #include "batch.h"
2 #include "error.h"
3
4 using namespace std;
5
6 namespace {
7
8 template<typename T>
9 void append(vector<uint8_t> &data, T i)
10 {
11         data.insert(data.end(), sizeof(T), 0);
12         *(T *)(&data[data.size()-sizeof(T)]) = i;
13 }
14
15 template<typename T, typename U>
16 U convert(T n)
17 {
18         if(!static_cast<T>(~n))
19                 return ~0;
20         else
21                 return n;
22 }
23
24 template<typename T, typename U>
25 void expand(vector<uint8_t> &data)
26 {
27         unsigned count = data.size()/sizeof(T);
28         data.resize(count*sizeof(U));
29         for(unsigned i=count; i--;)
30                 *(U *)(&data[i*sizeof(U)]) = convert<T, U>(*(T *)(&data[i*sizeof(T)]));
31 }
32
33 template<typename T, typename U>
34 void shrink(vector<uint8_t> &data)
35 {
36         unsigned count = data.size()/sizeof(T);
37         for(unsigned i=0; i<count; ++i)
38                 *(U *)(&data[i*sizeof(U)]) = convert<T, U>(*(T *)(&data[i*sizeof(T)]));
39         data.resize(count*sizeof(U));
40 }
41
42 }
43
44 namespace Msp {
45 namespace GL {
46
47 Batch::Batch(PrimitiveType t):
48         BatchBackend(t),
49         prim_type(t),
50         index_type(VOID),
51         max_index(0)
52 {
53         set_index_type(UNSIGNED_SHORT);
54 }
55
56 void Batch::set_index_type(DataType t)
57 {
58         if(t==index_type)
59                 return;
60         if(t!=UNSIGNED_SHORT && t!=UNSIGNED_INT)
61                 throw invalid_argument("Batch::set_data_type");
62         if(t==UNSIGNED_SHORT && max_index>0xFFFE)
63                 throw invalid_operation("Batch::set_data_type");
64
65         if(index_type==UNSIGNED_SHORT && t==UNSIGNED_INT)
66                 expand<uint16_t, uint32_t>(data);
67         else if(index_type==UNSIGNED_INT && t==UNSIGNED_SHORT)
68                 shrink<uint32_t, uint16_t>(data);
69
70         index_type = t;
71         BatchBackend::set_index_type(t);
72         update_offset();
73         dirty = true;
74 }
75
76 Batch &Batch::append(unsigned i)
77 {
78         append_index(i);
79
80         update_offset();
81         dirty = true;
82
83         return *this;
84 }
85
86 Batch &Batch::append(const vector<unsigned> &ind)
87 {
88         if(ind.empty())
89                 return *this;
90
91         data.reserve(data.size()+ind.size()*get_index_size());
92         for(unsigned i: ind)
93                 append_index(i);
94
95         update_offset();
96         dirty = true;
97
98         return *this;
99 }
100
101 bool Batch::can_append(PrimitiveType other_type)
102 {
103         if(other_type!=prim_type)
104                 return false;
105         else if(prim_type==LINE_STRIP || prim_type==TRIANGLE_FAN)
106                 return check_restart(false);
107         else
108                 return true;
109 }
110
111 Batch &Batch::append(const Batch &other)
112 {
113         if(other.prim_type!=prim_type)
114                 throw invalid_argument("Batch::append");
115         if(prim_type==LINE_STRIP || prim_type==TRIANGLE_FAN)
116                 check_restart(true);
117
118         if(other.data.empty())
119                 return *this;
120
121         // TODO allow appending triangles to a triangle strip
122
123         if(prim_type==POINTS || prim_type==LINES || prim_type==TRIANGLES)
124                 ;
125         else if(check_restart(false))
126         {
127                 if(index_type==UNSIGNED_INT)
128                         ::append<uint32_t>(data, 0xFFFFFFFF);
129                 else
130                         ::append<uint16_t>(data, 0xFFFF);
131         }
132         else if(prim_type==TRIANGLE_STRIP)
133         {
134                 append(get_index(size()-1));
135                 append(other.get_index(0));
136                 if(size()&1)
137                         append(other.get_index(0));
138         }
139
140         unsigned count = other.size();
141         for(unsigned i=0; i<count; ++i)
142                 append_index(other.get_index(i));
143
144         update_offset();
145         dirty = true;
146
147         return *this;
148 }
149
150 void Batch::append_index(unsigned i)
151 {
152         if(data.empty())
153                 max_index = i;
154         else
155                 max_index = max(max_index, i);
156
157         if(index_type==UNSIGNED_SHORT && max_index>0xFFFE)
158                 set_index_type(UNSIGNED_INT);
159
160         if(index_type==UNSIGNED_INT)
161                 ::append<uint32_t>(data, i);
162         else
163                 ::append<uint16_t>(data, i);
164 }
165
166 unsigned Batch::get_index(size_t i) const
167 {
168         if(index_type==UNSIGNED_INT)
169                 return *(uint32_t *)&data[i*sizeof(uint32_t)];
170         else
171                 return *(uint16_t *)&data[i*sizeof(uint16_t)];
172 }
173
174
175 Batch::Loader::Loader(Batch &b):
176         DataFile::ObjectLoader<Batch>(b)
177 {
178         add("indices", &Loader::indices);
179 }
180
181 void Batch::Loader::indices(const vector<unsigned> &ind)
182 {
183         obj.append(ind);
184 }
185
186 } // namespace GL
187 } // namespace Msp