History

Introducing the COntext and the Backend object and the specialized GLBackend for the real OpenGL backend to the graphics api

Sam Gateau committed 12 years ago

Commit 2a5442e1 parent 88eaeae4 files · +940 −0Browse files

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

Unified · Split

interface/src/gpu/GLBackend.cpp+736−0
@@ -0,0 +1,736 @@
1+//
2+// GLBackend.cpp
3+// interface/src/gpu
4+//
5+// Created by Sam Gateau on 10/27/2014.
6+// Copyright 2014 High Fidelity, Inc.
7+//
8+// Distributed under the Apache License, Version 2.0.
9+// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
10+//
11+#include "GLBackend.h"
12+
13+#include <QDebug>
14+
15+#include "gpu/Resource.h"
16+
17+using namespace gpu;
18+
19+GLBackend::CommandCall GLBackend::_commandCalls[Batch::NUM_COMMANDS] =
20+{
21+ (&::gpu::GLBackend::do_glEnable),
22+ (&::gpu::GLBackend::do_glDisable),
23+
24+ (&::gpu::GLBackend::do_glEnableClientState),
25+ (&::gpu::GLBackend::do_glDisableClientState),
26+
27+ (&::gpu::GLBackend::do_glCullFace),
28+ (&::gpu::GLBackend::do_glAlphaFunc),
29+
30+ (&::gpu::GLBackend::do_glDepthFunc),
31+ (&::gpu::GLBackend::do_glDepthMask),
32+ (&::gpu::GLBackend::do_glDepthRange),
33+
34+ (&::gpu::GLBackend::do_glBindBuffer),
35+
36+ (&::gpu::GLBackend::do_glBindTexture),
37+ (&::gpu::GLBackend::do_glActiveTexture),
38+
39+ (&::gpu::GLBackend::do_glDrawBuffers),
40+
41+ (&::gpu::GLBackend::do_glUseProgram),
42+ (&::gpu::GLBackend::do_glUniform1f),
43+ (&::gpu::GLBackend::do_glUniformMatrix4fv),
44+
45+ (&::gpu::GLBackend::do_glMatrixMode),
46+ (&::gpu::GLBackend::do_glPushMatrix),
47+ (&::gpu::GLBackend::do_glPopMatrix),
48+ (&::gpu::GLBackend::do_glMultMatrixf),
49+ (&::gpu::GLBackend::do_glLoadMatrixf),
50+ (&::gpu::GLBackend::do_glLoadIdentity),
51+ (&::gpu::GLBackend::do_glRotatef),
52+ (&::gpu::GLBackend::do_glScalef),
53+ (&::gpu::GLBackend::do_glTranslatef),
54+
55+ (&::gpu::GLBackend::do_glDrawArrays),
56+ (&::gpu::GLBackend::do_glDrawRangeElements),
57+
58+ (&::gpu::GLBackend::do_glColorPointer),
59+ (&::gpu::GLBackend::do_glNormalPointer),
60+ (&::gpu::GLBackend::do_glTexCoordPointer),
61+ (&::gpu::GLBackend::do_glVertexPointer),
62+
63+ (&::gpu::GLBackend::do_glVertexAttribPointer),
64+ (&::gpu::GLBackend::do_glEnableVertexAttribArray),
65+ (&::gpu::GLBackend::do_glDisableVertexAttribArray),
66+
67+ (&::gpu::GLBackend::do_glColor4f),
68+
69+ (&::gpu::GLBackend::do_glMaterialf),
70+ (&::gpu::GLBackend::do_glMaterialfv),
71+};
72+
73+
74+GLBackend::GLBackend() {
75+
76+}
77+
78+GLBackend::~GLBackend() {
79+
80+}
81+
82+void GLBackend::renderBatch(Batch& batch) {
83+ uint32 numCommands = batch.getCommands().size();
84+ const Batch::Commands::value_type* command = batch.getCommands().data();
85+ const Batch::CommandOffsets::value_type* offset = batch.getCommandOffsets().data();
86+
87+ GLBackend backend;
88+
89+ for (int i = 0; i < numCommands; i++) {
90+ CommandCall call = _commandCalls[((*command) - Batch::COMMAND_glEnable)];
91+ (backend.*(call))(batch, *offset);
92+ command++;
93+ offset++;
94+ }
95+}
96+
97+void GLBackend::checkGLError() {
98+ GLenum error = glGetError();
99+ if (!error) {
100+ return;
101+ }
102+ else {
103+ switch (error) {
104+ case GL_INVALID_ENUM:
105+ qDebug() << "An unacceptable value is specified for an enumerated argument.The offending command is ignored and has no other side effect than to set the error flag.";
106+ break;
107+ case GL_INVALID_VALUE:
108+ qDebug() << "A numeric argument is out of range.The offending command is ignored and has no other side effect than to set the error flag";
109+ break;
110+ case GL_INVALID_OPERATION:
111+ qDebug() << "The specified operation is not allowed in the current state.The offending command is ignored and has no other side effect than to set the error flag..";
112+ break;
113+ case GL_INVALID_FRAMEBUFFER_OPERATION:
114+ qDebug() << "The framebuffer object is not complete.The offending command is ignored and has no other side effect than to set the error flag.";
115+ break;
116+ case GL_OUT_OF_MEMORY:
117+ qDebug() << "There is not enough memory left to execute the command.The state of the GL is undefined, except for the state of the error flags, after this error is recorded.";
118+ break;
119+ case GL_STACK_UNDERFLOW:
120+ qDebug() << "An attempt has been made to perform an operation that would cause an internal stack to underflow.";
121+ break;
122+ case GL_STACK_OVERFLOW:
123+ qDebug() << "An attempt has been made to perform an operation that would cause an internal stack to overflow.";
124+ break;
125+ }
126+ }
127+}
128+
129+
130+// TODO: As long as we have gl calls explicitely issued from interface
131+// code, we need to be able to record and batch these calls. THe long
132+// term strategy is to get rid of any GL calls in favor of the HIFI GPU API
133+
134+//#define ADD_COMMAND(call) _commands.push_back(COMMAND_##call); _commandCalls.push_back(&gpu::Batch::do_##call); _commandOffsets.push_back(_params.size());
135+#define ADD_COMMAND(call) _commands.push_back(COMMAND_##call); _commandOffsets.push_back(_params.size());
136+//#define ADD_COMMAND_GL(call) _commands.push_back(COMMAND_##call); _commandCalls.push_back(&gpu::GLBackend::do_##call); _commandOffsets.push_back(_params.size());
137+#define ADD_COMMAND_GL(call) _commands.push_back(COMMAND_##call); _commandOffsets.push_back(_params.size());
138+
139+//#define DO_IT_NOW(call, offset) runLastCommand();
140+#define DO_IT_NOW(call, offset)
141+
142+//#define CHECK_GL_ERROR() ::gpu::backend::checkGLError()
143+#define CHECK_GL_ERROR()
144+
145+void Batch::_glEnable(GLenum cap) {
146+ ADD_COMMAND(glEnable);
147+
148+ _params.push_back(cap);
149+
150+ DO_IT_NOW(_glEnable, 1);
151+}
152+void GLBackend::do_glEnable(Batch& batch, uint32 paramOffset) {
153+ glEnable(batch._params[paramOffset]._uint);
154+ CHECK_GL_ERROR();
155+}
156+
157+void Batch::_glDisable(GLenum cap) {
158+ ADD_COMMAND(glDisable);
159+
160+ _params.push_back(cap);
161+
162+ DO_IT_NOW(_glDisable, 1);
163+}
164+void GLBackend::do_glDisable(Batch& batch, uint32 paramOffset) {
165+ glDisable(batch._params[paramOffset]._uint);
166+ CHECK_GL_ERROR();
167+}
168+
169+void Batch::_glEnableClientState(GLenum array) {
170+ ADD_COMMAND(glEnableClientState);
171+
172+ _params.push_back(array);
173+
174+ DO_IT_NOW(_glEnableClientState, 1);
175+}
176+void GLBackend::do_glEnableClientState(Batch& batch, uint32 paramOffset) {
177+ glEnableClientState(batch._params[paramOffset]._uint);
178+ CHECK_GL_ERROR();
179+}
180+
181+void Batch::_glDisableClientState(GLenum array) {
182+ ADD_COMMAND(glDisableClientState);
183+
184+ _params.push_back(array);
185+
186+ DO_IT_NOW(_glDisableClientState, 1);
187+}
188+void GLBackend::do_glDisableClientState(Batch& batch, uint32 paramOffset) {
189+ glDisableClientState(batch._params[paramOffset]._uint);
190+ CHECK_GL_ERROR();
191+}
192+
193+void Batch::_glCullFace(GLenum mode) {
194+ ADD_COMMAND(glCullFace);
195+
196+ _params.push_back(mode);
197+
198+ DO_IT_NOW(_glCullFace, 1);
199+}
200+void GLBackend::do_glCullFace(Batch& batch, uint32 paramOffset) {
201+ glCullFace(batch._params[paramOffset]._uint);
202+ CHECK_GL_ERROR();
203+}
204+
205+void Batch::_glAlphaFunc(GLenum func, GLclampf ref) {
206+ ADD_COMMAND(glAlphaFunc);
207+
208+ _params.push_back(ref);
209+ _params.push_back(func);
210+
211+ DO_IT_NOW(_glAlphaFunc, 2);
212+}
213+void GLBackend::do_glAlphaFunc(Batch& batch, uint32 paramOffset) {
214+ glAlphaFunc(
215+ batch._params[paramOffset + 1]._uint,
216+ batch._params[paramOffset + 0]._float);
217+ CHECK_GL_ERROR();
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 GLBackend::do_glDepthFunc(Batch& batch, uint32 paramOffset) {
228+ glDepthFunc(batch._params[paramOffset]._uint);
229+ CHECK_GL_ERROR();
230+}
231+
232+void Batch::_glDepthMask(GLboolean flag) {
233+ ADD_COMMAND(glDepthMask);
234+
235+ _params.push_back(flag);
236+
237+ DO_IT_NOW(_glDepthMask, 1);
238+}
239+void GLBackend::do_glDepthMask(Batch& batch, uint32 paramOffset) {
240+ glDepthMask(batch._params[paramOffset]._uint);
241+ CHECK_GL_ERROR();
242+}
243+
244+void Batch::_glDepthRange(GLclampd zNear, GLclampd zFar) {
245+ ADD_COMMAND(glDepthRange);
246+
247+ _params.push_back(zFar);
248+ _params.push_back(zNear);
249+
250+ DO_IT_NOW(_glDepthRange, 2);
251+}
252+void GLBackend::do_glDepthRange(Batch& batch, uint32 paramOffset) {
253+ glDepthRange(
254+ batch._params[paramOffset + 1]._double,
255+ batch._params[paramOffset + 0]._double);
256+ CHECK_GL_ERROR();
257+}
258+
259+void Batch::_glBindBuffer(GLenum target, GLuint buffer) {
260+ ADD_COMMAND(glBindBuffer);
261+
262+ _params.push_back(buffer);
263+ _params.push_back(target);
264+
265+ DO_IT_NOW(_glBindBuffer, 2);
266+}
267+void GLBackend::do_glBindBuffer(Batch& batch, uint32 paramOffset) {
268+ glBindBuffer(
269+ batch._params[paramOffset + 1]._uint,
270+ batch._params[paramOffset + 0]._uint);
271+ CHECK_GL_ERROR();
272+}
273+
274+void Batch::_glBindTexture(GLenum target, GLuint texture) {
275+ ADD_COMMAND(glBindTexture);
276+
277+ _params.push_back(texture);
278+ _params.push_back(target);
279+
280+ DO_IT_NOW(_glBindTexture, 2);
281+}
282+void GLBackend::do_glBindTexture(Batch& batch, uint32 paramOffset) {
283+ glBindTexture(
284+ batch._params[paramOffset + 1]._uint,
285+ batch._params[paramOffset + 0]._uint);
286+ CHECK_GL_ERROR();
287+}
288+
289+void Batch::_glActiveTexture(GLenum texture) {
290+ ADD_COMMAND(glActiveTexture);
291+
292+ _params.push_back(texture);
293+
294+ DO_IT_NOW(_glActiveTexture, 1);
295+}
296+void GLBackend::do_glActiveTexture(Batch& batch, uint32 paramOffset) {
297+ glActiveTexture(batch._params[paramOffset]._uint);
298+ CHECK_GL_ERROR();
299+}
300+
301+void Batch::_glDrawBuffers(GLsizei n, const GLenum* bufs) {
302+ ADD_COMMAND(glDrawBuffers);
303+
304+ _params.push_back(cacheData(n * sizeof(GLenum), bufs));
305+ _params.push_back(n);
306+
307+ DO_IT_NOW(_glDrawBuffers, 2);
308+}
309+void GLBackend::do_glDrawBuffers(Batch& batch, uint32 paramOffset) {
310+ glDrawBuffers(
311+ batch._params[paramOffset + 1]._uint,
312+ (const GLenum*)batch.editData(batch._params[paramOffset + 0]._uint));
313+ CHECK_GL_ERROR();
314+}
315+
316+void Batch::_glUseProgram(GLuint program) {
317+ ADD_COMMAND(glUseProgram);
318+
319+ _params.push_back(program);
320+
321+ DO_IT_NOW(_glUseProgram, 1);
322+}
323+void GLBackend::do_glUseProgram(Batch& batch, uint32 paramOffset) {
324+ glUseProgram(batch._params[paramOffset]._uint);
325+ CHECK_GL_ERROR();
326+}
327+
328+void Batch::_glUniform1f(GLint location, GLfloat v0) {
329+ ADD_COMMAND(glUniform1f);
330+
331+ _params.push_back(v0);
332+ _params.push_back(location);
333+
334+ DO_IT_NOW(_glUniform1f, 1);
335+}
336+void GLBackend::do_glUniform1f(Batch& batch, uint32 paramOffset) {
337+ glUniform1f(
338+ batch._params[paramOffset + 1]._int,
339+ batch._params[paramOffset + 0]._float);
340+ CHECK_GL_ERROR();
341+}
342+
343+void Batch::_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
344+ ADD_COMMAND(glUniformMatrix4fv);
345+
346+ const int MATRIX4_SIZE = 16 * sizeof(float);
347+ _params.push_back(cacheData(count * MATRIX4_SIZE, value));
348+ _params.push_back(transpose);
349+ _params.push_back(count);
350+ _params.push_back(location);
351+
352+ DO_IT_NOW(_glUniformMatrix4fv, 4);
353+}
354+void GLBackend::do_glUniformMatrix4fv(Batch& batch, uint32 paramOffset) {
355+ glUniformMatrix4fv(
356+ batch._params[paramOffset + 3]._int,
357+ batch._params[paramOffset + 2]._uint,
358+ batch._params[paramOffset + 1]._uint,
359+ (const GLfloat*)batch.editData(batch._params[paramOffset + 0]._uint));
360+ CHECK_GL_ERROR();
361+}
362+
363+void Batch::_glMatrixMode(GLenum mode) {
364+ ADD_COMMAND(glMatrixMode);
365+
366+ _params.push_back(mode);
367+
368+ DO_IT_NOW(_glMatrixMode, 1);
369+}
370+void GLBackend::do_glMatrixMode(Batch& batch, uint32 paramOffset) {
371+ glMatrixMode(batch._params[paramOffset]._uint);
372+ CHECK_GL_ERROR();
373+}
374+
375+void Batch::_glPushMatrix() {
376+ ADD_COMMAND(glPushMatrix);
377+
378+ DO_IT_NOW(_glPushMatrix, 0);
379+}
380+void GLBackend::do_glPushMatrix(Batch& batch, uint32 paramOffset) {
381+ glPushMatrix();
382+ CHECK_GL_ERROR();
383+}
384+
385+void Batch::_glPopMatrix() {
386+ ADD_COMMAND(glPopMatrix);
387+
388+ DO_IT_NOW(_glPopMatrix, 0);
389+}
390+void GLBackend::do_glPopMatrix(Batch& batch, uint32 paramOffset) {
391+ glPopMatrix();
392+ CHECK_GL_ERROR();
393+}
394+
395+void Batch::_glMultMatrixf(const GLfloat *m) {
396+ ADD_COMMAND(glMultMatrixf);
397+
398+ const int MATRIX4_SIZE = 16 * sizeof(float);
399+ _params.push_back(cacheData(MATRIX4_SIZE, m));
400+
401+ DO_IT_NOW(_glMultMatrixf, 1);
402+}
403+void GLBackend::do_glMultMatrixf(Batch& batch, uint32 paramOffset) {
404+ glMultMatrixf((const GLfloat*)batch.editData(batch._params[paramOffset]._uint));
405+ CHECK_GL_ERROR();
406+}
407+
408+void Batch::_glLoadMatrixf(const GLfloat *m) {
409+ ADD_COMMAND(glLoadMatrixf);
410+
411+ const int MATRIX4_SIZE = 16 * sizeof(float);
412+ _params.push_back(cacheData(MATRIX4_SIZE, m));
413+
414+ DO_IT_NOW(_glLoadMatrixf, 1);
415+}
416+void GLBackend::do_glLoadMatrixf(Batch& batch, uint32 paramOffset) {
417+ glLoadMatrixf((const GLfloat*)batch.editData(batch._params[paramOffset]._uint));
418+ CHECK_GL_ERROR();
419+}
420+
421+void Batch::_glLoadIdentity(void) {
422+ ADD_COMMAND(glLoadIdentity);
423+
424+ DO_IT_NOW(_glLoadIdentity, 0);
425+}
426+void GLBackend::do_glLoadIdentity(Batch& batch, uint32 paramOffset) {
427+ glLoadIdentity();
428+ CHECK_GL_ERROR();
429+}
430+
431+void Batch::_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
432+ ADD_COMMAND(glRotatef);
433+
434+ _params.push_back(z);
435+ _params.push_back(y);
436+ _params.push_back(x);
437+ _params.push_back(angle);
438+
439+ DO_IT_NOW(_glRotatef, 4);
440+}
441+void GLBackend::do_glRotatef(Batch& batch, uint32 paramOffset) {
442+ glRotatef(
443+ batch._params[paramOffset + 3]._float,
444+ batch._params[paramOffset + 2]._float,
445+ batch._params[paramOffset + 1]._float,
446+ batch._params[paramOffset + 0]._float);
447+ CHECK_GL_ERROR();
448+}
449+
450+void Batch::_glScalef(GLfloat x, GLfloat y, GLfloat z) {
451+ ADD_COMMAND(glScalef);
452+
453+ _params.push_back(z);
454+ _params.push_back(y);
455+ _params.push_back(x);
456+
457+ DO_IT_NOW(_glScalef, 3);
458+}
459+void GLBackend::do_glScalef(Batch& batch, uint32 paramOffset) {
460+ glScalef(
461+ batch._params[paramOffset + 2]._float,
462+ batch._params[paramOffset + 1]._float,
463+ batch._params[paramOffset + 0]._float);
464+ CHECK_GL_ERROR();
465+}
466+
467+void Batch::_glTranslatef(GLfloat x, GLfloat y, GLfloat z) {
468+ ADD_COMMAND(glTranslatef);
469+
470+ _params.push_back(z);
471+ _params.push_back(y);
472+ _params.push_back(x);
473+
474+ DO_IT_NOW(_glTranslatef, 3);
475+}
476+void GLBackend::do_glTranslatef(Batch& batch, uint32 paramOffset) {
477+ glTranslatef(
478+ batch._params[paramOffset + 2]._float,
479+ batch._params[paramOffset + 1]._float,
480+ batch._params[paramOffset + 0]._float);
481+ CHECK_GL_ERROR();
482+}
483+
484+void Batch::_glDrawArrays(GLenum mode, GLint first, GLsizei count) {
485+ ADD_COMMAND(glDrawArrays);
486+
487+ _params.push_back(count);
488+ _params.push_back(first);
489+ _params.push_back(mode);
490+
491+ DO_IT_NOW(_glDrawArrays, 3);
492+}
493+void GLBackend::do_glDrawArrays(Batch& batch, uint32 paramOffset) {
494+ glDrawArrays(
495+ batch._params[paramOffset + 2]._uint,
496+ batch._params[paramOffset + 1]._int,
497+ batch._params[paramOffset + 0]._int);
498+ CHECK_GL_ERROR();
499+}
500+
501+void Batch::_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices) {
502+ ADD_COMMAND(glDrawRangeElements);
503+
504+ _params.push_back(cacheResource(indices));
505+ _params.push_back(type);
506+ _params.push_back(count);
507+ _params.push_back(end);
508+ _params.push_back(start);
509+ _params.push_back(mode);
510+
511+ DO_IT_NOW(_glDrawRangeElements, 6);
512+}
513+void GLBackend::do_glDrawRangeElements(Batch& batch, uint32 paramOffset) {
514+ glDrawRangeElements(
515+ batch._params[paramOffset + 5]._uint,
516+ batch._params[paramOffset + 4]._uint,
517+ batch._params[paramOffset + 3]._uint,
518+ batch._params[paramOffset + 2]._int,
519+ batch._params[paramOffset + 1]._uint,
520+ batch.editResource(batch._params[paramOffset + 0]._uint)->_pointer);
521+ CHECK_GL_ERROR();
522+}
523+
524+void Batch::_glColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) {
525+ ADD_COMMAND(glColorPointer);
526+
527+ _params.push_back(cacheResource(pointer));
528+ _params.push_back(stride);
529+ _params.push_back(type);
530+ _params.push_back(size);
531+
532+ DO_IT_NOW(_glColorPointer, 4);
533+}
534+void GLBackend::do_glColorPointer(Batch& batch, uint32 paramOffset) {
535+ glColorPointer(
536+ batch._params[paramOffset + 3]._int,
537+ batch._params[paramOffset + 2]._uint,
538+ batch._params[paramOffset + 1]._int,
539+ batch.editResource(batch._params[paramOffset + 0]._uint)->_pointer);
540+ CHECK_GL_ERROR();
541+}
542+
543+void Batch::_glNormalPointer(GLenum type, GLsizei stride, const void *pointer) {
544+ ADD_COMMAND(glNormalPointer);
545+
546+ _params.push_back(cacheResource(pointer));
547+ _params.push_back(stride);
548+ _params.push_back(type);
549+
550+ DO_IT_NOW(_glNormalPointer, 3);
551+}
552+void GLBackend::do_glNormalPointer(Batch& batch, uint32 paramOffset) {
553+ glNormalPointer(
554+ batch._params[paramOffset + 2]._uint,
555+ batch._params[paramOffset + 1]._int,
556+ batch.editResource(batch._params[paramOffset + 0]._uint)->_pointer);
557+ CHECK_GL_ERROR();
558+}
559+
560+void Batch::_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) {
561+ ADD_COMMAND(glTexCoordPointer);
562+
563+ _params.push_back(cacheResource(pointer));
564+ _params.push_back(stride);
565+ _params.push_back(type);
566+ _params.push_back(size);
567+
568+ DO_IT_NOW(_glTexCoordPointer, 4);
569+}
570+void GLBackend::do_glTexCoordPointer(Batch& batch, uint32 paramOffset) {
571+ glTexCoordPointer(
572+ batch._params[paramOffset + 3]._int,
573+ batch._params[paramOffset + 2]._uint,
574+ batch._params[paramOffset + 1]._int,
575+ batch.editResource(batch._params[paramOffset + 0]._uint)->_pointer);
576+ CHECK_GL_ERROR();
577+}
578+
579+void Batch::_glVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) {
580+ ADD_COMMAND(glVertexPointer);
581+
582+ _params.push_back(cacheResource(pointer));
583+ _params.push_back(stride);
584+ _params.push_back(type);
585+ _params.push_back(size);
586+
587+ DO_IT_NOW(_glVertexPointer, 4);
588+}
589+void GLBackend::do_glVertexPointer(Batch& batch, uint32 paramOffset) {
590+ glVertexPointer(
591+ batch._params[paramOffset + 3]._int,
592+ batch._params[paramOffset + 2]._uint,
593+ batch._params[paramOffset + 1]._int,
594+ batch.editResource(batch._params[paramOffset + 0]._uint)->_pointer);
595+ CHECK_GL_ERROR();
596+}
597+
598+
599+void Batch::_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) {
600+ ADD_COMMAND(glVertexAttribPointer);
601+
602+ _params.push_back(cacheResource(pointer));
603+ _params.push_back(stride);
604+ _params.push_back(normalized);
605+ _params.push_back(type);
606+ _params.push_back(size);
607+ _params.push_back(index);
608+
609+ DO_IT_NOW(_glVertexAttribPointer, 6);
610+}
611+void GLBackend::do_glVertexAttribPointer(Batch& batch, uint32 paramOffset) {
612+ glVertexAttribPointer(
613+ batch._params[paramOffset + 5]._uint,
614+ batch._params[paramOffset + 4]._int,
615+ batch._params[paramOffset + 3]._uint,
616+ batch._params[paramOffset + 2]._uint,
617+ batch._params[paramOffset + 1]._int,
618+ batch.editResource(batch._params[paramOffset + 0]._uint)->_pointer);
619+ CHECK_GL_ERROR();
620+}
621+
622+void Batch::_glEnableVertexAttribArray(GLint location) {
623+ ADD_COMMAND(glEnableVertexAttribArray);
624+
625+ _params.push_back(location);
626+
627+ DO_IT_NOW(_glEnableVertexAttribArray, 1);
628+}
629+void GLBackend::do_glEnableVertexAttribArray(Batch& batch, uint32 paramOffset) {
630+ glEnableVertexAttribArray(batch._params[paramOffset]._uint);
631+ CHECK_GL_ERROR();
632+}
633+
634+void Batch::_glDisableVertexAttribArray(GLint location) {
635+ ADD_COMMAND(glDisableVertexAttribArray);
636+
637+ _params.push_back(location);
638+
639+ DO_IT_NOW(_glDisableVertexAttribArray, 1);
640+}
641+void GLBackend::do_glDisableVertexAttribArray(Batch& batch, uint32 paramOffset) {
642+ glDisableVertexAttribArray(batch._params[paramOffset]._uint);
643+ CHECK_GL_ERROR();
644+}
645+
646+void Batch::_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
647+ ADD_COMMAND(glColor4f);
648+
649+ _params.push_back(alpha);
650+ _params.push_back(blue);
651+ _params.push_back(green);
652+ _params.push_back(red);
653+
654+ DO_IT_NOW(_glColor4f, 4);
655+}
656+void GLBackend::do_glColor4f(Batch& batch, uint32 paramOffset) {
657+ glColor4f(
658+ batch._params[paramOffset + 3]._float,
659+ batch._params[paramOffset + 2]._float,
660+ batch._params[paramOffset + 1]._float,
661+ batch._params[paramOffset + 0]._float);
662+ CHECK_GL_ERROR();
663+}
664+
665+void Batch::_glMaterialf(GLenum face, GLenum pname, GLfloat param) {
666+ ADD_COMMAND(glMaterialf);
667+
668+ _params.push_back(param);
669+ _params.push_back(pname);
670+ _params.push_back(face);
671+
672+ DO_IT_NOW(_glMaterialf, 3);
673+}
674+void GLBackend::do_glMaterialf(Batch& batch, uint32 paramOffset) {
675+ glMaterialf(
676+ batch._params[paramOffset + 2]._uint,
677+ batch._params[paramOffset + 1]._uint,
678+ batch._params[paramOffset + 0]._float);
679+ CHECK_GL_ERROR();
680+}
681+
682+void Batch::_glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) {
683+ ADD_COMMAND(glMaterialfv);
684+
685+ _params.push_back(cacheData(4 * sizeof(float), params));
686+ _params.push_back(pname);
687+ _params.push_back(face);
688+
689+ DO_IT_NOW(_glMaterialfv, 3);
690+}
691+void GLBackend::do_glMaterialfv(Batch& batch, uint32 paramOffset) {
692+ glMaterialfv(
693+ batch._params[paramOffset + 2]._uint,
694+ batch._params[paramOffset + 1]._uint,
695+ (const GLfloat*)batch.editData(batch._params[paramOffset + 0]._uint));
696+ CHECK_GL_ERROR();
697+}
698+
699+
700+GLBackend::BufferObject::~BufferObject() {
701+ if (_buffer != 0) {
702+ glDeleteBuffers(1, &_buffer);
703+ }
704+}
705+
706+void GLBackend::syncGPUObject(const Buffer& buffer) {
707+ BufferObject* object = Backend::getGPUObject<GLBackend::BufferObject>(buffer);
708+
709+ if (object && (object->_stamp == buffer.getSysmem().getStamp())) {
710+ return;
711+ }
712+
713+ // need to have a gpu object?
714+ if (!object) {
715+ object = new BufferObject();
716+ glGenBuffers(1, &object->_buffer);
717+ Backend::setGPUObject(buffer, object);
718+ }
719+
720+ // Now let's update the content of the bo with the sysmem version
721+ // TODO: in the future, be smarter about when to actually upload the glBO version based on the data that did change
722+ //if () {
723+ glBindBuffer(GL_ARRAY_BUFFER, object->_buffer);
724+ glBufferData(GL_ARRAY_BUFFER, buffer.getSysmem().getSize(), buffer.getSysmem().readData(), GL_DYNAMIC_DRAW);
725+ glBindBuffer(GL_ARRAY_BUFFER, 0);
726+ object->_stamp = buffer.getSysmem().getStamp();
727+ object->_size = buffer.getSysmem().getSize();
728+ //}
729+}
730+
731+
732+
733+GLuint GLBackend::getBufferID(const Buffer& buffer) {
734+ GLBackend::syncGPUObject(buffer);
735+ return Backend::getGPUObject<GLBackend::BufferObject>(buffer)->_buffer;
736+}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t