FIrst working version of the GLBatching system introduced in the MOdelrendering path

Sam Gateau committed 12 years ago

Commit 00dbe481 parent 0def4903 files · +659 −414Browse files

Showing the changes to interface/src/gpu/Batch.cpp (1 of 3 files). Show all

Unified · Split

@@ -12,14 +12,21 @@ · 11 unmodified lines
12	12
13	13	#include <QDebug>
14	14
15		−#define DO_IT_NOW(call, offset) int param = _params.size() - (offset); do##call(param);
	15	+#define ADD_COMMAND(call) _commands.push_back(COMMAND_##call); _commandCalls.push_back(&gpu::Batch::do_##call); _commandOffsets.push_back(_params.size());
	16	+
	17	+//#define DO_IT_NOW(call, offset) uint32 __param = _params.size() - (offset); do##call(__param);
	18	+//#define DO_IT_NOW(call, offset) uint32 __param = _commandOffsets.back(); CommandCall call = _commandCalls.back(); (this->*(call))(__param);
	19	+//#define DO_IT_NOW(call, offset) runLastCommand();
	20	+//#define DO_IT_NOW(call, offset) uint32 __param = _params.size() - (offset); runCommand(_commands.size() -1);// do##call(__param);
	21	+#define DO_IT_NOW(call, offset)
16	22
17	23	using namespace gpu;
18	24
19	25	Batch::Batch() :
20	26	_commands(),
21	27	_params(),
22		− _resources(){
	28	+ _resources(),
	29	+ _data(){
23	30	}
24	31
25	32	Batch::~Batch() {
@@ -29,24 +36,99 @@ void Batch::clear() { · 3 unmodified lines
29	36	_commands.clear();
30	37	_params.clear();
31	38	_resources.clear();
	39	+ _data.clear();
	40	+}
	41	+
	42	+uint32 Batch::cacheResource(Resource* res) {
	43	+ uint32 offset = _resources.size();
	44	+ _resources.push_back(ResourceCache(res));
	45	+
	46	+ return offset;
	47	+}
	48	+
	49	+uint32 Batch::cacheResource(const void* pointer) {
	50	+ uint32 offset = _resources.size();
	51	+ _resources.push_back(ResourceCache(pointer));
	52	+
	53	+ return offset;
	54	+}
	55	+
	56	+uint32 Batch::cacheData(uint32 size, const void* data) {
	57	+ uint32 offset = _data.size();
	58	+ uint32 nbBytes = size;
	59	+ _data.resize(offset + nbBytes);
	60	+ memcpy(_data.data() + offset, data, size);
	61	+
	62	+ return offset;
	63	+}
	64	+
	65	+#define CASE_COMMAND(call) case COMMAND_##call: { do_##call(offset); } break;
	66	+
	67	+void Batch::runCommand(Command com, uint32 offset) {
	68	+ switch (com) {
	69	+ CASE_COMMAND(draw);
	70	+ CASE_COMMAND(drawIndexed);
	71	+ CASE_COMMAND(drawInstanced);
	72	+ CASE_COMMAND(drawIndexedInstanced);
	73	+ CASE_COMMAND(glEnable);
	74	+ CASE_COMMAND(glDisable);
	75	+ CASE_COMMAND(glEnableClientState);
	76	+ CASE_COMMAND(glDisableClientState);
	77	+ CASE_COMMAND(glCullFace);
	78	+ CASE_COMMAND(glAlphaFunc);
	79	+ CASE_COMMAND(glDepthFunc);
	80	+ CASE_COMMAND(glDepthMask);
	81	+ CASE_COMMAND(glDepthRange);
	82	+ CASE_COMMAND(glBindBuffer);
	83	+ CASE_COMMAND(glBindTexture);
	84	+ CASE_COMMAND(glActiveTexture);
	85	+ CASE_COMMAND(glDrawBuffers);
	86	+ CASE_COMMAND(glUseProgram);
	87	+ CASE_COMMAND(glUniform1f);
	88	+ CASE_COMMAND(glUniformMatrix4fv);
	89	+ CASE_COMMAND(glMatrixMode);
	90	+ CASE_COMMAND(glPushMatrix);
	91	+ CASE_COMMAND(glPopMatrix);
	92	+ CASE_COMMAND(glMultMatrixf);
	93	+ CASE_COMMAND(glLoadMatrixf);
	94	+ CASE_COMMAND(glLoadIdentity);
	95	+ CASE_COMMAND(glRotatef);
	96	+ CASE_COMMAND(glScalef);
	97	+ CASE_COMMAND(glTranslatef);
	98	+ CASE_COMMAND(glDrawArrays);
	99	+ CASE_COMMAND(glDrawRangeElements);
	100	+ CASE_COMMAND(glColorPointer);
	101	+ CASE_COMMAND(glNormalPointer);
	102	+ CASE_COMMAND(glTexCoordPointer);
	103	+ CASE_COMMAND(glVertexPointer);
	104	+ CASE_COMMAND(glVertexAttribPointer);
	105	+ CASE_COMMAND(glEnableVertexAttribArray);
	106	+ CASE_COMMAND(glDisableVertexAttribArray);
	107	+ CASE_COMMAND(glColor4f);
	108	+ CASE_COMMAND(glMaterialf);
	109	+ CASE_COMMAND(glMaterialfv);
	110	+ }
32	111	}
33	112
34	113	void Batch::draw( Primitive primitiveType, int nbVertices, int startVertex) {
35		− _commands.push_back(COMMAND_DRAW);
	114	+ ADD_COMMAND(draw);
	115	+
36	116	_params.push_back(startVertex);
37	117	_params.push_back(nbVertices);
38	118	_params.push_back(primitiveType);
39	119	}
40	120
41	121	void Batch::drawIndexed( Primitive primitiveType, int nbIndices, int startIndex) {
42		− _commands.push_back(COMMAND_DRAW_INDEXED);
	122	+ ADD_COMMAND(drawIndexed);
	123	+
43	124	_params.push_back(startIndex);
44	125	_params.push_back(nbIndices);
45	126	_params.push_back(primitiveType);
46	127	}
47	128
48	129	void Batch::drawInstanced( uint32 nbInstances, Primitive primitiveType, int nbVertices, int startVertex, int startInstance) {
49		− _commands.push_back(COMMAND_DRAW_INSTANCED);
	130	+ ADD_COMMAND(drawInstanced);
	131	+
50	132	_params.push_back(startInstance);
51	133	_params.push_back(startVertex);
52	134	_params.push_back(nbVertices);
@@ -55,7 +137,8 @@ void Batch::drawInstanced( uint32 nbInstances, Primitive primitiveType, int nbVe · 2 unmodified lines
55	137	}
56	138
57	139	void Batch::drawIndexedInstanced( uint32 nbInstances, Primitive primitiveType, int nbIndices, int startIndex, int startInstance) {
58		− _commands.push_back(COMMAND_DRAW_INDEXED_INSTANCED);
	140	+ ADD_COMMAND(drawIndexedInstanced);
	141	+
59	142	_params.push_back(startInstance);
60	143	_params.push_back(startIndex);
61	144	_params.push_back(nbIndices);
@@ -67,402 +150,474 @@ void Batch::drawIndexedInstanced( uint32 nbInstances, Primitive primitiveType, i · 5 unmodified lines
67	150	// code, we need to be able to record and batch these calls. THe long
68	151	// term strategy is to get rid of any GL calls in favor of the HIFI GPU API
69	152
70		−void Batch::_glEnable(GLenum cap) {
71		− _commands.push_back(COMMAND_glEnable);
72		− _params.push_back(cap);
73		−
74		− DO_IT_NOW(_glEnable, 1);
75		−}
76		−void Batch::do_glEnable(int &paramOffset) {
	153	+void Batch::_glEnable(GLenum cap) {
	154	+ ADD_COMMAND(glEnable);
	155	+
	156	+ _params.push_back(cap);
	157	+
	158	+ DO_IT_NOW(_glEnable, 1);
	159	+}
	160	+void Batch::do_glEnable(uint32& paramOffset) {
77	161	glEnable(_params[paramOffset++]._uint);
78		−}
79		−
80		−void Batch::_glDisable(GLenum cap) {
81		− _commands.push_back(COMMAND_glDisable);
82		− _params.push_back(cap);
83		−
84		− DO_IT_NOW(_glDisable, 1);
85		−}
86		−void Batch::do_glDisable(int &paramOffset) {
	162	+}
	163	+
	164	+void Batch::_glDisable(GLenum cap) {
	165	+ ADD_COMMAND(glDisable);
	166	+
	167	+ _params.push_back(cap);
	168	+
	169	+ DO_IT_NOW(_glDisable, 1);
	170	+}
	171	+void Batch::do_glDisable(uint32& paramOffset) {
87	172	glDisable(_params[paramOffset++]._uint);
88		−}
89		−
90		−void Batch::_glEnableClientState(GLenum array) {
91		− _commands.push_back(COMMAND_glEnableClientState);
92		− _params.push_back(array);
93		−
94		− DO_IT_NOW(_glEnableClientState, 1 );
95		−}
96		−void Batch::do_glEnableClientState(int &paramOffset) {
	173	+}
	174	+
	175	+void Batch::_glEnableClientState(GLenum array) {
	176	+ ADD_COMMAND(glEnableClientState);
	177	+
	178	+ _params.push_back(array);
	179	+
	180	+ DO_IT_NOW(_glEnableClientState, 1 );
	181	+}
	182	+void Batch::do_glEnableClientState(uint32& paramOffset) {
97	183	glEnableClientState(_params[paramOffset++]._uint);
98		−}
	184	+}
	185	+
	186	+void Batch::_glDisableClientState(GLenum array) {
	187	+ ADD_COMMAND(glDisableClientState);
	188	+
	189	+ _params.push_back(array);
99	190
100		−void Batch::_glDisableClientState(GLenum array) {
101		− _commands.push_back(COMMAND_glDisableClientState);
102		− _params.push_back(array);
103		−
104		− DO_IT_NOW(_glDisableClientState, 1);
	191	+ DO_IT_NOW(_glDisableClientState, 1);
105	192	}
106		−void Batch::do_glDisableClientState(int &paramOffset) {
	193	+void Batch::do_glDisableClientState(uint32& paramOffset) {
107	194	glDisableClientState(_params[paramOffset++]._uint);
108	195	}
109	196
110		−void Batch::_glCullFace(GLenum mode) {
111		− _commands.push_back(COMMAND_glCullFace);
112		− _params.push_back(mode);
113		−
114		− DO_IT_NOW(_glCullFace, 1);
	197	+void Batch::_glCullFace(GLenum mode) {
	198	+ ADD_COMMAND(glCullFace);
	199	+
	200	+ _params.push_back(mode);
	201	+
	202	+ DO_IT_NOW(_glCullFace, 1);
115	203	}
116		−void Batch::do_glCullFace(int &paramOffset) {
	204	+void Batch::do_glCullFace(uint32& paramOffset) {
117	205	glCullFace(_params[paramOffset++]._uint);
118	206	}
119	207
120		−void Batch::_glAlphaFunc(GLenum func, GLclampf ref) {
121		− _commands.push_back(COMMAND_glAlphaFunc);
122		− _params.push_back(ref);
123		− _params.push_back(func);
124		−
125		− DO_IT_NOW(_glAlphaFunc, 1);
	208	+void Batch::_glAlphaFunc(GLenum func, GLclampf ref) {
	209	+ ADD_COMMAND(glAlphaFunc);
	210	+
	211	+ _params.push_back(ref);
	212	+ _params.push_back(func);
	213	+
	214	+ DO_IT_NOW(_glAlphaFunc, 2);
126	215	}
127		−void Batch::do_glAlphaFunc(int &paramOffset) {
	216	+void Batch::do_glAlphaFunc(uint32& paramOffset) {
128	217	glAlphaFunc(_params[paramOffset++]._uint, _params[paramOffset++]._float);
129		−}
130		−
131		−void Batch::_glDepthFunc(GLenum func) {
132		− _commands.push_back(COMMAND_glDepthFunc);
133		− _params.push_back(func);
134		−
135		− DO_IT_NOW(_glDepthFunc, 1);
136		−}
137		−void Batch::do_glDepthFunc(int &paramOffset) {
	218	+}
	219	+
	220	+void Batch::_glDepthFunc(GLenum func) {
	221	+ ADD_COMMAND(glDepthFunc);
	222	+
	223	+ _params.push_back(func);
	224	+
	225	+ DO_IT_NOW(_glDepthFunc, 1);
	226	+}
	227	+void Batch::do_glDepthFunc(uint32& paramOffset) {
138	228	glDepthFunc(_params[paramOffset++]._uint);
139		−}
140		−
141		−void Batch::_glDepthMask(GLboolean flag) {
142		− _commands.push_back(COMMAND_glDepthMask);
143		− _params.push_back(flag);
144		−
145		− DO_IT_NOW(_glDepthMask, 1);
146		−}
147		−void Batch::do_glDepthMask(int &paramOffset) {
	229	+}
	230	+
	231	+void Batch::_glDepthMask(GLboolean flag) {
	232	+ ADD_COMMAND(glDepthMask);
	233	+
	234	+ _params.push_back(flag);
	235	+
	236	+ DO_IT_NOW(_glDepthMask, 1);
	237	+}
	238	+void Batch::do_glDepthMask(uint32& paramOffset) {
148	239	glDepthMask(_params[paramOffset++]._uint);
149		−}
150		−
151		−void Batch::_glDepthRange(GLclampd zNear, GLclampd zFar) {
152		− _commands.push_back(COMMAND_glDepthRange);
153		− _params.push_back(zFar);
154		− _params.push_back(zNear);
155		−
156		− DO_IT_NOW(_glDepthRange, 2);
157		−}
158		−void Batch::do_glDepthRange(int &paramOffset) {
	240	+}
	241	+
	242	+void Batch::_glDepthRange(GLclampd zNear, GLclampd zFar) {
	243	+ ADD_COMMAND(glDepthRange);
	244	+
	245	+ _params.push_back(zFar);
	246	+ _params.push_back(zNear);
	247	+
	248	+ DO_IT_NOW(_glDepthRange, 2);
	249	+}
	250	+void Batch::do_glDepthRange(uint32& paramOffset) {
159	251	glDepthRange(_params[paramOffset++]._double, _params[paramOffset++]._double);
160	252	}
161	253
162		−void Batch::_glBindBuffer(GLenum target, GLuint buffer) {
163		− _commands.push_back(COMMAND_glBindBuffer);
164		− _params.push_back(buffer);
165		− _params.push_back(target);
166		−
167		− DO_IT_NOW(_glBindBuffer, 2);
168		−}
169		−void Batch::do_glBindBuffer(int &paramOffset) {
	254	+void Batch::_glBindBuffer(GLenum target, GLuint buffer) {
	255	+ ADD_COMMAND(glBindBuffer);
	256	+
	257	+ _params.push_back(buffer);
	258	+ _params.push_back(target);
	259	+
	260	+ DO_IT_NOW(_glBindBuffer, 2);
	261	+}
	262	+void Batch::do_glBindBuffer(uint32& paramOffset) {
170	263	glBindBuffer(_params[paramOffset++]._uint, _params[paramOffset++]._uint);
171	264	}
172	265
173		−void Batch::_glBindTexture(GLenum target, GLuint texture) {
174		− _commands.push_back(COMMAND_glBindTexture);
175		− _params.push_back(texture);
176		− _params.push_back(target);
177		−
178		− DO_IT_NOW(_glBindTexture, 2);
179		−}
180		−void Batch::do_glBindTexture(int &paramOffset) {
	266	+void Batch::_glBindTexture(GLenum target, GLuint texture) {
	267	+ ADD_COMMAND(glBindTexture);
	268	+
	269	+ _params.push_back(texture);
	270	+ _params.push_back(target);
	271	+
	272	+ DO_IT_NOW(_glBindTexture, 2);
	273	+}
	274	+void Batch::do_glBindTexture(uint32& paramOffset) {
181	275	glBindTexture(_params[paramOffset++]._uint, _params[paramOffset++]._uint);
182	276	}
183	277
184		−void Batch::_glActiveTexture(GLenum texture) {
185		− _commands.push_back(COMMAND_glActiveTexture);
186		− _params.push_back(texture);
187		−
188		− DO_IT_NOW(_glActiveTexture, 1);
189		−}
190		−void Batch::do_glActiveTexture(int &paramOffset) {
	278	+void Batch::_glActiveTexture(GLenum texture) {
	279	+ ADD_COMMAND(glActiveTexture);
	280	+
	281	+ _params.push_back(texture);
	282	+
	283	+ DO_IT_NOW(_glActiveTexture, 1);
	284	+}
	285	+void Batch::do_glActiveTexture(uint32& paramOffset) {
191	286	glActiveTexture(_params[paramOffset++]._uint);
192	287	}
193	288
194		−void Batch::_glDrawBuffers(GLsizei n, const GLenum* bufs) {
195		− _commands.push_back(COMMAND_glDrawBuffers);
196		− _params.push_back(bufs);
197		− _params.push_back(n);
198		−
199		− DO_IT_NOW(_glDrawBuffers, 2);
200		−}
201		−void Batch::do_glDrawBuffers(int &paramOffset) {
202		− glDrawBuffers(_params[paramOffset++]._uint, (const GLenum*) _params[paramOffset++]._constPointer);
203		−}
204		−
205		−void Batch::_glUseProgram(GLuint program) {
206		− _commands.push_back(COMMAND_glUseProgram);
207		− _params.push_back(program);
208		−
209		− DO_IT_NOW(_glUseProgram, 1);
210		−}
211		−void Batch::do_glUseProgram(int &paramOffset) {
	289	+void Batch::_glDrawBuffers(GLsizei n, const GLenum* bufs) {
	290	+ ADD_COMMAND(glDrawBuffers);
	291	+
	292	+ _params.push_back(cacheData(n * sizeof(GLenum), bufs));
	293	+ _params.push_back(n);
	294	+
	295	+ DO_IT_NOW(_glDrawBuffers, 2);
	296	+}
	297	+void Batch::do_glDrawBuffers(uint32& paramOffset) {
	298	+ glDrawBuffers(_params[paramOffset++]._uint, (const GLenum*) editData(_params[paramOffset++]._uint));
	299	+}
	300	+
	301	+void Batch::_glUseProgram(GLuint program) {
	302	+ ADD_COMMAND(glUseProgram);
	303	+
	304	+ _params.push_back(program);
	305	+
	306	+ DO_IT_NOW(_glUseProgram, 1);
	307	+}
	308	+void Batch::do_glUseProgram(uint32& paramOffset) {
212	309	glUseProgram(_params[paramOffset++]._uint);
213	310	}
214		−
215		−void Batch::_glUniform1f(GLint location, GLfloat v0) {
216		− _commands.push_back(COMMAND_glUniform1f);
217		− _params.push_back(v0);
218		− _params.push_back(location);
219		−
220		− DO_IT_NOW(_glUniform1f, 1);
221		−}
222		−void Batch::do_glUniform1f(int &paramOffset) {
223		− glUniform1f(_params[paramOffset++]._float);
224		−}
225		−
226		−void Batch::_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
227		− _commands.push_back(COMMAND_glUniformMatrix4fv);
228		− _params.push_back(value);
229		− _params.push_back(transpose);
230		− _params.push_back(count);
231		− _params.push_back(location);
232		−
233		− DO_IT_NOW(_glUniformMatrix4fv, 4);
234		−}
235		−void Batch::do_glUniformMatrix4fv(int &paramOffset) {
236		− glUniformMatrix4fv(_params[paramOffset++]._int, _params[paramOffset++]._uint, _params[paramOffset++]._uint, _params[paramOffset++]._constPointer);
237		−}
238		−
239		−void Batch::_glMatrixMode(GLenum mode) {
240		− _commands.push_back(COMMAND_glMatrixMode);
241		− _params.push_back(mode);
242		−
243		− DO_IT_NOW(_glMatrixMode, 1);
244		−}
245		−void Batch::do_glMatrixMode(int &paramOffset) {
	311	+
	312	+void Batch::_glUniform1f(GLint location, GLfloat v0) {
	313	+ ADD_COMMAND(glUniform1f);
	314	+
	315	+ _params.push_back(v0);
	316	+ _params.push_back(location);
	317	+
	318	+ DO_IT_NOW(_glUniform1f, 1);
	319	+}
	320	+void Batch::do_glUniform1f(uint32& paramOffset) {
	321	+ glUniform1f(_params[paramOffset++]._int, _params[paramOffset++]._float);
	322	+}
	323	+
	324	+void Batch::_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
	325	+ ADD_COMMAND(glUniformMatrix4fv);
	326	+
	327	+ const int MATRIX4_SIZE = 16 * sizeof(float);
	328	+ _params.push_back(cacheData(count * MATRIX4_SIZE, value));
	329	+ _params.push_back(transpose);
	330	+ _params.push_back(count);
	331	+ _params.push_back(location);
	332	+
	333	+ DO_IT_NOW(_glUniformMatrix4fv, 4);
	334	+}
	335	+void Batch::do_glUniformMatrix4fv(uint32& paramOffset) {
	336	+ glUniformMatrix4fv(_params[paramOffset++]._int, _params[paramOffset++]._uint,
	337	+ _params[paramOffset++]._uint, (const GLfloat*) editData(_params[paramOffset++]._uint));
	338	+}
	339	+
	340	+void Batch::_glMatrixMode(GLenum mode) {
	341	+ ADD_COMMAND(glMatrixMode);
	342	+
	343	+ _params.push_back(mode);
	344	+
	345	+ DO_IT_NOW(_glMatrixMode, 1);
	346	+}
	347	+void Batch::do_glMatrixMode(uint32& paramOffset) {
246	348	glMatrixMode(_params[paramOffset++]._uint);
247	349	}
248	350
249		−void Batch::_glPushMatrix() {
250		− _commands.push_back(COMMAND_glPushMatrix);
251		−
252		− DO_IT_NOW(_glPushMatrix, 0);
253		−}
254		−void Batch::do_glPushMatrix(int &paramOffset) {
	351	+void Batch::_glPushMatrix() {
	352	+ ADD_COMMAND(glPushMatrix);
	353	+
	354	+ DO_IT_NOW(_glPushMatrix, 0);
	355	+}
	356	+void Batch::do_glPushMatrix(uint32& paramOffset) {
255	357	glPushMatrix();
256	358	}
257	359
258		−void Batch::_glPopMatrix() {
259		− _commands.push_back(COMMAND_glPopMatrix);
	360	+void Batch::_glPopMatrix() {
	361	+ ADD_COMMAND(glPopMatrix);
260	362
261	363	DO_IT_NOW(_glPopMatrix, 0);
262		−}
263		−void Batch::do_glPopMatrix(int &paramOffset) {
	364	+}
	365	+void Batch::do_glPopMatrix(uint32& paramOffset) {
264	366	glPopMatrix();
265	367	}
266	368
267		−void Batch::_glMultMatrixf(const GLfloat *m) {
268		− _commands.push_back(COMMAND_glMultMatrixf);
269		− _params.push_back(m);
270		−
	369	+void Batch::_glMultMatrixf(const GLfloat *m) {
	370	+ ADD_COMMAND(glMultMatrixf);
	371	+
	372	+ const int MATRIX4_SIZE = 16 * sizeof(float);
	373	+ _params.push_back(cacheData(MATRIX4_SIZE, m));
	374	+
271	375	DO_IT_NOW(_glMultMatrixf, 1);
272		−}
273		−void Batch::do_glMultMatrixf(int &paramOffset) {
274		− glMultMatrixf((const GLfloat*) _params[paramOffset++]._constPointer);
275		−}
276		−
277		−void Batch::_glLoadMatrixf(const GLfloat *m) {
278		− _commands.push_back(COMMAND_glLoadMatrixf);
279		− _params.push_back(m);
280		−
281		− DO_IT_NOW(_glLoadMatrixf, 1);
282		−}
283		−void Batch::do_glLoadMatrixf(int &paramOffset) {
284		− glLoadMatrixf((const GLfloat*)_params[paramOffset++]._constPointer);
285		−}
286		−
287		−void Batch::_glLoadIdentity(void) {
288		− _commands.push_back(COMMAND_glLoadIdentity);
289		−
290		− DO_IT_NOW(_glLoadIdentity, 0);
291		−}
292		−void Batch::do_glLoadIdentity(int &paramOffset) {
	376	+}
	377	+void Batch::do_glMultMatrixf(uint32& paramOffset) {
	378	+ glMultMatrixf((const GLfloat*) editData(_params[paramOffset++]._uint));
	379	+}
	380	+
	381	+void Batch::_glLoadMatrixf(const GLfloat *m) {
	382	+ ADD_COMMAND(glLoadMatrixf);
	383	+
	384	+ const int MATRIX4_SIZE = 16 * sizeof(float);
	385	+ _params.push_back(cacheData(MATRIX4_SIZE, m));
	386	+
	387	+ DO_IT_NOW(_glLoadMatrixf, 1);
	388	+}
	389	+void Batch::do_glLoadMatrixf(uint32& paramOffset) {
	390	+ glLoadMatrixf((const GLfloat*)editData(_params[paramOffset++]._uint));
	391	+}
	392	+
	393	+void Batch::_glLoadIdentity(void) {
	394	+ ADD_COMMAND(glLoadIdentity);
	395	+
	396	+ DO_IT_NOW(_glLoadIdentity, 0);
	397	+}
	398	+void Batch::do_glLoadIdentity(uint32& paramOffset) {
293	399	glLoadIdentity();
294		−}
295		−
296		−void Batch::_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
297		− _commands.push_back(COMMAND_glRotatef);
298		− _params.push_back(z);
299		− _params.push_back(y);
300		− _params.push_back(x);
301		− _params.push_back(angle);
302		−
303		− DO_IT_NOW(_glRotatef, 4);
304		−}
305		−void Batch::do_glRotatef(int &paramOffset) {
	400	+}
	401	+
	402	+void Batch::_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
	403	+ ADD_COMMAND(glRotatef);
	404	+
	405	+ _params.push_back(z);
	406	+ _params.push_back(y);
	407	+ _params.push_back(x);
	408	+ _params.push_back(angle);
	409	+
	410	+ DO_IT_NOW(_glRotatef, 4);
	411	+}
	412	+void Batch::do_glRotatef(uint32& paramOffset) {
306	413	glRotatef(_params[paramOffset++]._float, _params[paramOffset++]._float, _params[paramOffset++]._float, _params[paramOffset++]._float);
307		−}
308		−
309		−void Batch::_glScalef(GLfloat x, GLfloat y, GLfloat z) {
310		− _commands.push_back(COMMAND_glScalef);
311		− _params.push_back(z);
312		− _params.push_back(y);
313		− _params.push_back(x);
314		−
315		− DO_IT_NOW(_glScalef, 3);
316		−}
317		−void Batch::do_glScalef(int &paramOffset) {
	414	+}
	415	+
	416	+void Batch::_glScalef(GLfloat x, GLfloat y, GLfloat z) {
	417	+ ADD_COMMAND(glScalef);
	418	+
	419	+ _params.push_back(z);
	420	+ _params.push_back(y);
	421	+ _params.push_back(x);
	422	+
	423	+ DO_IT_NOW(_glScalef, 3);
	424	+}
	425	+void Batch::do_glScalef(uint32& paramOffset) {
318	426	glScalef(_params[paramOffset++]._float, _params[paramOffset++]._float, _params[paramOffset++]._float);
319		−}
320		−
321		−void Batch::_glTranslatef(GLfloat x, GLfloat y, GLfloat z) {
322		− _commands.push_back(COMMAND_glTranslatef);
323		− _params.push_back(z);
324		− _params.push_back(y);
325		− _params.push_back(x);
326		−
327		− DO_IT_NOW(_glTranslatef, 3);
328		−}
329		−void Batch::do_glTranslatef(int &paramOffset) {
	427	+}
	428	+
	429	+void Batch::_glTranslatef(GLfloat x, GLfloat y, GLfloat z) {
	430	+ ADD_COMMAND(glTranslatef);
	431	+
	432	+ _params.push_back(z);
	433	+ _params.push_back(y);
	434	+ _params.push_back(x);
	435	+
	436	+ DO_IT_NOW(_glTranslatef, 3);
	437	+}
	438	+void Batch::do_glTranslatef(uint32& paramOffset) {
330	439	glTranslatef(_params[paramOffset++]._float, _params[paramOffset++]._float, _params[paramOffset++]._float);
331		−}
332		−
333		−void Batch::_glDrawArrays(GLenum mode, GLint first, GLsizei count) {
334		− _commands.push_back(COMMAND_glDrawArrays);
335		− _params.push_back(count);
336		− _params.push_back(first);
337		− _params.push_back(mode);
338		−
339		− DO_IT_NOW(_glDrawArrays, 3);
340		−}
341		−void Batch::do_glDrawArrays(int &paramOffset) {
	440	+}
	441	+
	442	+void Batch::_glDrawArrays(GLenum mode, GLint first, GLsizei count) {
	443	+ ADD_COMMAND(glDrawArrays);
	444	+
	445	+ _params.push_back(count);
	446	+ _params.push_back(first);
	447	+ _params.push_back(mode);
	448	+
	449	+ DO_IT_NOW(_glDrawArrays, 3);
	450	+}
	451	+void Batch::do_glDrawArrays(uint32& paramOffset) {
342	452	glDrawArrays(_params[paramOffset++]._uint, _params[paramOffset++]._int, _params[paramOffset++]._int);
343		−}
344		−
345		−void Batch::_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices) {
346		− _commands.push_back(COMMAND_glDrawRangeElements);
347		− _params.push_back(indices);
348		− _params.push_back(type);
349		− _params.push_back(count);
350		− _params.push_back(end);
351		− _params.push_back(start);
352		− _params.push_back(mode);
353		−
354		− DO_IT_NOW(_glDrawRangeElements, 6);
355		−}
356		−void Batch::do_glDrawRangeElements(int &paramOffset) {
357		− glDrawRangeElements(_params[paramOffset++]._uint, _params[paramOffset++]._uint, _params[paramOffset++]._uint, _params[paramOffset++]._int, _params[paramOffset++]._uint, _params[paramOffset++]._constPointer);
358		−}
359		−
360		−void Batch::_glColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) {
361		− _commands.push_back(COMMAND_glColorPointer);
362		− _params.push_back(pointer);
363		− _params.push_back(stride);
364		− _params.push_back(type);
365		− _params.push_back(size);
366		−
367		− DO_IT_NOW(_glColorPointer, 4);
368		−}
369		−void Batch::do_glColorPointer(int &paramOffset) {
370		− glColorPointer(_params[paramOffset++]._int, _params[paramOffset++]._uint, _params[paramOffset++]._int, _params[paramOffset++]._constPointer);
371		−}
372		−
373		−void Batch::_glNormalPointer(GLenum type, GLsizei stride, const void *pointer) {
374		− _commands.push_back(COMMAND_glNormalPointer);
375		− _params.push_back(pointer);
376		− _params.push_back(stride);
377		− _params.push_back(type);
378		−
379		− DO_IT_NOW(_glNormalPointer, 4);
380		−}
381		−void Batch::do_glNormalPointer(int &paramOffset) {
382		− glNormalPointer(_params[paramOffset++]._uint, _params[paramOffset++]._int, _params[paramOffset++]._constPointer);
383		−}
384		−
385		−void Batch::_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) {
386		− _commands.push_back(COMMAND_glTexCoordPointer);
387		− _params.push_back(pointer);
388		− _params.push_back(stride);
389		− _params.push_back(type);
390		− _params.push_back(size);
391		−}
392		−void Batch::do_glCullFace(int &paramOffset) {
393		− glCullFace(_params[paramOffset++]._uint);
394		−}
395		−
396		−void Batch::_glVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) {
397		− _commands.push_back(COMMAND_glVertexPointer);
398		− _params.push_back(pointer);
399		− _params.push_back(stride);
400		− _params.push_back(type);
401		− _params.push_back(size);
402		−}
403		−void Batch::do_glCullFace(int &paramOffset) {
404		− glCullFace(_params[paramOffset++]._uint);
405	453	}
406	454
	455	+void Batch::_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices) {
	456	+ ADD_COMMAND(glDrawRangeElements);
407	457
408		−void Batch::_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) {
409		− _commands.push_back(COMMAND_glVertexPointer);
410		− _params.push_back(pointer);
411		− _params.push_back(stride);
412		− _params.push_back(normalized);
413		− _params.push_back(type);
414		− _params.push_back(size);
415		− _params.push_back(index);
416		−}
417		−void Batch::do_glCullFace(int &paramOffset) {
418		− glCullFace(_params[paramOffset++]._uint);
	458	+ _params.push_back(cacheResource(indices));
	459	+ _params.push_back(type);
	460	+ _params.push_back(count);
	461	+ _params.push_back(end);
	462	+ _params.push_back(start);
	463	+ _params.push_back(mode);
	464	+
	465	+ //do_glDrawRangeElements(_commandOffsets.back());
	466	+ // runCommand(_commands.size() - 1);
	467	+ DO_IT_NOW(_glDrawRangeElements, 6);
	468	+}
	469	+void Batch::do_glDrawRangeElements(uint32& paramOffset) {
	470	+ glDrawRangeElements(_params[paramOffset++]._uint, _params[paramOffset++]._uint,
	471	+ _params[paramOffset++]._uint, _params[paramOffset++]._int,
	472	+ _params[paramOffset++]._uint, editResource(_params[paramOffset++]._uint)->_pointer);
419	473	}
420	474
421		−void Batch::_glEnableVertexArrayAttrib(GLint location) {
422		− _commands.push_back(COMMAND_glEnableVertexArrayAttrib);
423		− _params.push_back(location);
424		−}
425		−void Batch::do_glCullFace(int &paramOffset) {
426		− glCullFace(_params[paramOffset++]._uint);
	475	+void Batch::_glColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) {
	476	+ ADD_COMMAND(glColorPointer);
	477	+
	478	+ _params.push_back(cacheResource(pointer));
	479	+ _params.push_back(stride);
	480	+ _params.push_back(type);
	481	+ _params.push_back(size);
	482	+
	483	+ DO_IT_NOW(_glColorPointer, 4);
	484	+}
	485	+void Batch::do_glColorPointer(uint32& paramOffset) {
	486	+ glColorPointer(_params[paramOffset++]._int, _params[paramOffset++]._uint,
	487	+ _params[paramOffset++]._int, editResource(_params[paramOffset++]._uint)->_pointer);
427	488	}
428	489
429		−void Batch::_glDisableVertexArrayAttrib(GLint location) {
430		− _commands.push_back(COMMAND_glDisableVertexArrayAttrib);
431		− _params.push_back(location);
432		−}
433		−void Batch::do_glCullFace(int &paramOffset) {
434		− glCullFace(_params[paramOffset++]._uint);
	490	+void Batch::_glNormalPointer(GLenum type, GLsizei stride, const void *pointer) {
	491	+ ADD_COMMAND(glNormalPointer);
	492	+
	493	+ _params.push_back(cacheResource(pointer));
	494	+ _params.push_back(stride);
	495	+ _params.push_back(type);
	496	+
	497	+ DO_IT_NOW(_glNormalPointer, 3);
	498	+}
	499	+void Batch::do_glNormalPointer(uint32& paramOffset) {
	500	+ glNormalPointer(_params[paramOffset++]._uint, _params[paramOffset++]._int,
	501	+ editResource(_params[paramOffset++]._uint)->_pointer);
435	502	}
436	503
437		−void Batch::_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
438		− _commands.push_back(COMMAND_glColor4f);
439		− _params.push_back(alpha);
440		− _params.push_back(blue);
441		− _params.push_back(green);
442		− _params.push_back(red);
443		−}
444		−void Batch::do_glCullFace(int &paramOffset) {
445		− glCullFace(_params[paramOffset++]._uint);
	504	+void Batch::_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) {
	505	+ ADD_COMMAND(glTexCoordPointer);
	506	+
	507	+ _params.push_back(cacheResource(pointer));
	508	+ _params.push_back(stride);
	509	+ _params.push_back(type);
	510	+ _params.push_back(size);
	511	+
	512	+ DO_IT_NOW(_glTexCoordPointer, 4);
	513	+}
	514	+void Batch::do_glTexCoordPointer(uint32& paramOffset) {
	515	+ glTexCoordPointer(_params[paramOffset++]._int, _params[paramOffset++]._uint,
	516	+ _params[paramOffset++]._int, editResource(_params[paramOffset++]._uint)->_pointer);
446	517	}
447	518
448		−void Batch::_glMaterialf(GLenum face, GLenum pname, GLfloat param) {
449		− _commands.push_back(COMMAND_glMaterialf);
450		− _params.push_back(param);
451		− _params.push_back(pname);
452		− _params.push_back(face);
453		−}
454		−void Batch::do_glCullFace(int &paramOffset) {
455		− glCullFace(_params[paramOffset++]._uint);
456		−}
457		−
458		−void Batch::_glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) {
459		− _commands.push_back(COMMAND_glMaterialfv);
460		− _params.push_back(params);
461		− _params.push_back(pname);
462		− _params.push_back(face);
463		−}
464		−void Batch::do_glCullFace(int &paramOffset) {
465		− glCullFace(_params[paramOffset++]._uint);
	519	+void Batch::_glVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) {
	520	+ ADD_COMMAND(glVertexPointer);
	521	+
	522	+ _params.push_back(cacheResource(pointer));
	523	+ _params.push_back(stride);
	524	+ _params.push_back(type);
	525	+ _params.push_back(size);
	526	+
	527	+ DO_IT_NOW(_glVertexPointer, 4);
	528	+}
	529	+void Batch::do_glVertexPointer(uint32& paramOffset) {
	530	+ glVertexPointer(_params[paramOffset++]._int, _params[paramOffset++]._uint,
	531	+ _params[paramOffset++]._int, editResource(_params[paramOffset++]._uint)->_pointer);
	532	+}
	533	+
	534	+
	535	+void Batch::_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) {
	536	+ ADD_COMMAND(glVertexAttribPointer);
	537	+
	538	+ _params.push_back(cacheResource(pointer));
	539	+ _params.push_back(stride);
	540	+ _params.push_back(normalized);
	541	+ _params.push_back(type);
	542	+ _params.push_back(size);
	543	+ _params.push_back(index);
	544	+
	545	+ DO_IT_NOW(_glVertexAttribPointer, 6);
	546	+}
	547	+void Batch::do_glVertexAttribPointer(uint32& paramOffset) {
	548	+ glVertexAttribPointer(_params[paramOffset++]._uint, _params[paramOffset++]._int,
	549	+ _params[paramOffset++]._uint, _params[paramOffset++]._uint,
	550	+ _params[paramOffset++]._int, editResource(_params[paramOffset++]._uint)->_pointer);
	551	+}
	552	+
	553	+
	554	+
	555	+void Batch::_glEnableVertexAttribArray(GLint location) {
	556	+ ADD_COMMAND(glEnableVertexAttribArray);
	557	+
	558	+ _params.push_back(location);
	559	+
	560	+ DO_IT_NOW(_glEnableVertexAttribArray, 1);
	561	+}
	562	+void Batch::do_glEnableVertexAttribArray(uint32& paramOffset) {
	563	+ glEnableVertexAttribArray(_params[paramOffset++]._uint);
466	564	}
467	565
	566	+void Batch::_glDisableVertexAttribArray(GLint location) {
	567	+ ADD_COMMAND(glDisableVertexAttribArray);
	568	+
	569	+ _params.push_back(location);
	570	+
	571	+ DO_IT_NOW(_glDisableVertexAttribArray, 1);
	572	+}
	573	+void Batch::do_glDisableVertexAttribArray(uint32& paramOffset) {
	574	+ glDisableVertexAttribArray(_params[paramOffset++]._uint);
	575	+}
	576	+
	577	+void Batch::_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
	578	+ ADD_COMMAND(glColor4f);
	579	+
	580	+ _params.push_back(alpha);
	581	+ _params.push_back(blue);
	582	+ _params.push_back(green);
	583	+ _params.push_back(red);
	584	+
	585	+ DO_IT_NOW(_glColor4f, 4);
	586	+}
	587	+void Batch::do_glColor4f(uint32& paramOffset) {
	588	+ glColor4f(_params[paramOffset++]._float, _params[paramOffset++]._float, _params[paramOffset++]._float, _params[paramOffset++]._float);
	589	+}
	590	+
	591	+void Batch::_glMaterialf(GLenum face, GLenum pname, GLfloat param) {
	592	+ ADD_COMMAND(glMaterialf);
	593	+
	594	+ _params.push_back(param);
	595	+ _params.push_back(pname);
	596	+ _params.push_back(face);
	597	+
	598	+ DO_IT_NOW(_glMaterialf, 3);
	599	+}
	600	+void Batch::do_glMaterialf(uint32& paramOffset) {
	601	+ glMaterialf(_params[paramOffset++]._uint, _params[paramOffset++]._uint, _params[paramOffset++]._float);
	602	+}
	603	+
	604	+void Batch::_glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) {
	605	+ ADD_COMMAND(glMaterialfv);
	606	+
	607	+ _params.push_back(cacheData(4 * sizeof(float), params));
	608	+ _params.push_back(pname);
	609	+ _params.push_back(face);
	610	+
	611	+ DO_IT_NOW(_glMaterialfv, 3);
	612	+}
	613	+void Batch::do_glMaterialfv(uint32& paramOffset) {
	614	+ glMaterialfv(_params[paramOffset++]._uint, _params[paramOffset++]._uint, (const GLfloat*) editData(_params[paramOffset++]._uint));
	615	+}
	616	+
	617	+
468	618
	619	+void backend::renderBatch(Batch& batch) {
	620	+ for (int i = 0; i < batch._commands.size(); i++) {
	621	+ batch.runCommand(i);
	622	+ }
	623	+}