this repo has no description
Added blit buffer optimization. Moved all blit drawing into GPU_FlushBlitBuffer(). GPU_BlitTransformMatrix() has not been converted yet.
+567
-229
+15
-7
SDL_gpu/OpenGL_common/SDL_gpuShapes_OpenGL.c
+15
-7
SDL_gpu/OpenGL_common/SDL_gpuShapes_OpenGL.c
···
23
23
static void Circle(GPU_ShapeRenderer* renderer, GPU_Target* target, float x, float y, float radius, SDL_Color color);
24
24
25
25
26
-
static inline void bindTexture(GPU_Renderer* renderer, GLuint handle)
26
+
27
+
static inline void bindTexture(GPU_Renderer* renderer, GPU_Image* image)
27
28
{
28
29
// Bind the texture to which subsequent calls refer
29
-
if(handle != ((RendererData_OpenGL*)renderer->data)->last_texture)
30
+
if(image != ((RendererData_OpenGL*)renderer->data)->last_image)
30
31
{
32
+
GLuint handle = ((ImageData_OpenGL*)image->data)->handle;
33
+
renderer->FlushBlitBuffer(renderer);
34
+
31
35
glBindTexture( GL_TEXTURE_2D, handle );
32
-
((RendererData_OpenGL*)renderer->data)->last_texture = handle;
36
+
((RendererData_OpenGL*)renderer->data)->last_image = image;
33
37
}
34
38
}
35
39
36
-
static inline void bindFramebuffer(GPU_Renderer* renderer, GLuint handle)
40
+
static inline void bindFramebuffer(GPU_Renderer* renderer, GPU_Target* target)
37
41
{
38
42
// Bind the FBO
39
-
if(handle != ((RendererData_OpenGL*)renderer->data)->last_framebuffer)
43
+
if(target != ((RendererData_OpenGL*)renderer->data)->last_target)
40
44
{
45
+
GLuint handle = ((TargetData_OpenGL*)target->data)->handle;
46
+
renderer->FlushBlitBuffer(renderer);
47
+
41
48
glBindFramebuffer(GL_FRAMEBUFFER, handle);
42
-
((RendererData_OpenGL*)renderer->data)->last_framebuffer = handle;
49
+
((RendererData_OpenGL*)renderer->data)->last_target = target;
43
50
}
44
51
}
45
52
···
58
65
return; \
59
66
float z = ((RendererData_OpenGL*)renderer->renderer->data)->z; \
60
67
\
61
-
bindFramebuffer(renderer->renderer, ((TargetData_OpenGL*)target->data)->handle); \
68
+
renderer->renderer->FlushBlitBuffer(renderer->renderer); \
69
+
bindFramebuffer(renderer->renderer, target); \
62
70
/*glPushAttrib(GL_COLOR_BUFFER_BIT);*/ \
63
71
if(target->useClip) \
64
72
{ \
+508
-188
SDL_gpu/OpenGL_common/SDL_gpu_OpenGL.c
+508
-188
SDL_gpu/OpenGL_common/SDL_gpu_OpenGL.c
···
7
7
#include "SDL_gpu_OpenGL_internal.h"
8
8
#include <math.h>
9
9
#include <strings.h>
10
+
int strcasecmp(const char*, const char *);
11
+
12
+
#ifndef M_PI
13
+
#define M_PI 3.14159265358979323846
14
+
#endif
10
15
11
16
static Uint8 isExtensionSupported(const char* extension_str)
12
17
{
···
51
56
return x;
52
57
}
53
58
54
-
static inline void bindTexture(GPU_Renderer* renderer, GLuint handle)
59
+
static inline void bindTexture(GPU_Renderer* renderer, GPU_Image* image)
55
60
{
56
61
// Bind the texture to which subsequent calls refer
57
-
if(handle != ((RendererData_OpenGL*)renderer->data)->last_texture)
62
+
if(image != ((RendererData_OpenGL*)renderer->data)->last_image)
58
63
{
64
+
GLuint handle = ((ImageData_OpenGL*)image->data)->handle;
65
+
renderer->FlushBlitBuffer(renderer);
66
+
59
67
glBindTexture( GL_TEXTURE_2D, handle );
60
-
((RendererData_OpenGL*)renderer->data)->last_texture = handle;
68
+
((RendererData_OpenGL*)renderer->data)->last_image = image;
61
69
}
62
70
}
63
71
64
-
static inline void bindFramebuffer(GPU_Renderer* renderer, GLuint handle)
72
+
static inline void flushAndBindTexture(GPU_Renderer* renderer, GLuint handle)
73
+
{
74
+
// Bind the texture to which subsequent calls refer
75
+
renderer->FlushBlitBuffer(renderer);
76
+
77
+
glBindTexture( GL_TEXTURE_2D, handle );
78
+
((RendererData_OpenGL*)renderer->data)->last_image = NULL;
79
+
}
80
+
81
+
static inline void bindFramebuffer(GPU_Renderer* renderer, GPU_Target* target)
65
82
{
66
83
// Bind the FBO
67
-
if(handle != ((RendererData_OpenGL*)renderer->data)->last_framebuffer)
84
+
if(target != ((RendererData_OpenGL*)renderer->data)->last_target)
68
85
{
86
+
GLuint handle = ((TargetData_OpenGL*)target->data)->handle;
87
+
renderer->FlushBlitBuffer(renderer);
88
+
69
89
glBindFramebuffer(GL_FRAMEBUFFER, handle);
70
-
((RendererData_OpenGL*)renderer->data)->last_framebuffer = handle;
90
+
((RendererData_OpenGL*)renderer->data)->last_target = target;
91
+
}
92
+
}
93
+
94
+
static inline void flushAndBindFramebuffer(GPU_Renderer* renderer, GLuint handle)
95
+
{
96
+
// Bind the FBO
97
+
renderer->FlushBlitBuffer(renderer);
98
+
99
+
glBindFramebuffer(GL_FRAMEBUFFER, handle);
100
+
((RendererData_OpenGL*)renderer->data)->last_target = NULL;
101
+
}
102
+
103
+
static inline void flushBlitBufferIfCurrentTexture(GPU_Renderer* renderer, GPU_Image* image)
104
+
{
105
+
if(image == ((RendererData_OpenGL*)renderer->data)->last_image)
106
+
{
107
+
renderer->FlushBlitBuffer(renderer);
71
108
}
72
109
}
73
110
111
+
static inline void flushAndClearBlitBufferIfCurrentTexture(GPU_Renderer* renderer, GPU_Image* image)
112
+
{
113
+
if(image == ((RendererData_OpenGL*)renderer->data)->last_image)
114
+
{
115
+
renderer->FlushBlitBuffer(renderer);
116
+
((RendererData_OpenGL*)renderer->data)->last_image = NULL;
117
+
}
118
+
}
119
+
120
+
static inline void flushBlitBufferIfCurrentFramebuffer(GPU_Renderer* renderer, GPU_Target* target)
121
+
{
122
+
if(target == ((RendererData_OpenGL*)renderer->data)->last_target)
123
+
{
124
+
renderer->FlushBlitBuffer(renderer);
125
+
}
126
+
}
127
+
128
+
static inline void flushAndClearBlitBufferIfCurrentFramebuffer(GPU_Renderer* renderer, GPU_Target* target)
129
+
{
130
+
if(target == ((RendererData_OpenGL*)renderer->data)->last_target)
131
+
{
132
+
renderer->FlushBlitBuffer(renderer);
133
+
((RendererData_OpenGL*)renderer->data)->last_target = NULL;
134
+
}
135
+
}
74
136
75
137
76
138
static GPU_Target* Init(GPU_Renderer* renderer, Uint16 w, Uint16 h, Uint32 flags)
···
189
251
renderer->display->clipRect.w = renderer->display->w;
190
252
renderer->display->clipRect.h = renderer->display->h;
191
253
192
-
/*RendererData_OpenGL* rdata = (RendererData_OpenGL*)renderer->data;
193
-
rdata->blit_buffer_max_size = 4000;
254
+
RendererData_OpenGL* rdata = (RendererData_OpenGL*)renderer->data;
255
+
rdata->blit_buffer_max_size = GPU_BLIT_BUFFER_INIT_MAX_SIZE;
194
256
rdata->blit_buffer_size = 0;
195
-
rdata->blit_buffer = (float*)malloc(sizeof(float)*blit_buffer_max_size);*/
257
+
int numFloatsPerVertex = 5; // x, y, z, s, t
258
+
rdata->blit_buffer = (float*)malloc(sizeof(float)*rdata->blit_buffer_max_size*numFloatsPerVertex);
196
259
197
260
return renderer->display;
198
261
}
···
205
268
#endif
206
269
}
207
270
208
-
// FIXME: Rename to SetWindowResolution
271
+
// TODO: Rename to SetWindowResolution
209
272
static int SetDisplayResolution(GPU_Renderer* renderer, Uint16 w, Uint16 h)
210
273
{
211
274
if(renderer->display == NULL)
···
267
330
268
331
renderer->display->w = w;
269
332
renderer->display->h = h;
333
+
334
+
renderer->FlushBlitBuffer(renderer);
270
335
271
336
glMatrixMode( GL_PROJECTION );
272
337
glLoadIdentity();
···
327
392
{
328
393
renderer->camera = *cam;
329
394
}
395
+
396
+
renderer->FlushBlitBuffer(renderer);
330
397
331
398
glMatrixMode( GL_PROJECTION );
332
399
glLoadIdentity();
···
385
452
return NULL;
386
453
}
387
454
388
-
bindTexture( renderer, handle );
455
+
flushAndBindTexture( renderer, handle );
389
456
390
457
// Set the texture's stretching properties
391
458
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
···
433
500
}
434
501
435
502
glEnable(GL_TEXTURE_2D);
436
-
bindTexture( renderer, ((ImageData_OpenGL*)(result->data))->handle );
503
+
bindTexture(renderer, result);
437
504
438
505
GLenum internal_format = ((ImageData_OpenGL*)(result->data))->format;
439
506
w = result->w;
···
474
541
475
542
static void readTexPixels(GPU_Renderer* renderer, GPU_Target* source, unsigned int width, unsigned int height, GLint format, GLubyte* pixels)
476
543
{
477
-
bindFramebuffer(renderer, ((TargetData_OpenGL*)source->data)->handle);
544
+
flushBlitBufferIfCurrentFramebuffer(renderer, source);
545
+
bindFramebuffer(renderer, source);
478
546
glReadPixels(0, 0, width, height, format, GL_UNSIGNED_BYTE, pixels);
479
547
}
480
548
···
815
883
816
884
SDL_Surface* newSurface = copySurfaceIfNeeded(data->format, surface, NULL);
817
885
if(newSurface == NULL)
818
-
{
886
+
{
819
887
GPU_LogError("GPU_UpdateImage() failed to convert surface to proper pixel format.\n");
820
-
return;
821
-
}
888
+
return;
889
+
}
822
890
823
891
824
892
SDL_Rect updateRect;
···
834
902
835
903
836
904
glEnable(GL_TEXTURE_2D);
837
-
bindTexture(renderer, data->handle);
905
+
if(image->target != NULL)
906
+
flushBlitBufferIfCurrentFramebuffer(renderer, image->target);
907
+
bindTexture(renderer, image);
838
908
int alignment = 1;
839
909
if(newSurface->format->BytesPerPixel == 4)
840
910
alignment = 4;
···
885
955
}
886
956
887
957
glEnable(GL_TEXTURE_2D);
888
-
bindTexture(renderer, data->handle);
958
+
bindTexture(renderer, image);
889
959
int alignment = 1;
890
960
if(newSurface->format->BytesPerPixel == 4)
891
961
alignment = 4;
···
979
1049
// Delete the attached target first
980
1050
if(image->target != NULL)
981
1051
renderer->FreeTarget(renderer, image->target);
982
-
1052
+
1053
+
flushAndClearBlitBufferIfCurrentTexture(renderer, image);
983
1054
glDeleteTextures( 1, &((ImageData_OpenGL*)image->data)->handle);
984
1055
free(image->data);
985
1056
free(image);
···
1006
1077
r.h = src->h;
1007
1078
}
1008
1079
1009
-
bindTexture( renderer, ((ImageData_OpenGL*)dest->image->data)->handle );
1080
+
bindTexture(renderer, dest->image);
1010
1081
1011
1082
//GLenum texture_format = GL_RGBA;//((ImageData_OpenGL*)image->data)->format;
1012
1083
···
1075
1146
GLuint handle;
1076
1147
// Create framebuffer object
1077
1148
glGenFramebuffers(1, &handle);
1078
-
bindFramebuffer(renderer, handle);
1149
+
flushAndBindFramebuffer(renderer, handle);
1079
1150
1080
1151
// Attach the texture to it
1081
1152
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, ((ImageData_OpenGL*)image->data)->handle, 0);
···
1111
1182
if(target == NULL || target == renderer->display)
1112
1183
return;
1113
1184
1185
+
flushAndClearBlitBufferIfCurrentFramebuffer(renderer, target);
1114
1186
glDeleteFramebuffers(1, &((TargetData_OpenGL*)target->data)->handle);
1115
1187
1116
1188
if(target->image != NULL)
···
1130
1202
1131
1203
1132
1204
// Bind the texture to which subsequent calls refer
1133
-
bindTexture( renderer, ((ImageData_OpenGL*)src->data)->handle );
1205
+
bindTexture(renderer, src);
1134
1206
1135
1207
// Bind the FBO
1136
-
bindFramebuffer(renderer, ((TargetData_OpenGL*)dest->data)->handle);
1137
-
1138
-
// Modify the viewport and projection matrix if rendering to a texture
1139
-
GLint vp[4];
1140
-
if(renderer->display != dest)
1141
-
{
1142
-
glGetIntegerv(GL_VIEWPORT, vp);
1143
-
1144
-
unsigned int w = dest->w;
1145
-
unsigned int h = dest->h;
1146
-
1147
-
glViewport( 0, 0, w, h);
1148
-
1149
-
glMatrixMode( GL_PROJECTION );
1150
-
glPushMatrix();
1151
-
glLoadIdentity();
1152
-
1153
-
glOrtho(0.0f, w, 0.0f, h, -1.0f, 1.0f); // Special inverted orthographic projection because tex coords are inverted already.
1154
-
1155
-
glMatrixMode( GL_MODELVIEW );
1156
-
}
1157
-
1158
-
1159
-
if(dest->useClip)
1160
-
{
1161
-
glEnable(GL_SCISSOR_TEST);
1162
-
int y = (renderer->display == dest? renderer->display->h - (dest->clipRect.y + dest->clipRect.h) : dest->clipRect.y);
1163
-
float xFactor = ((float)renderer->window_w)/renderer->display->w;
1164
-
float yFactor = ((float)renderer->window_h)/renderer->display->h;
1165
-
glScissor(dest->clipRect.x * xFactor, y * yFactor, dest->clipRect.w * xFactor, dest->clipRect.h * yFactor);
1166
-
}
1208
+
bindFramebuffer(renderer, dest);
1167
1209
1168
1210
Uint16 tex_w = ((ImageData_OpenGL*)src->data)->tex_w;
1169
1211
Uint16 tex_h = ((ImageData_OpenGL*)src->data)->tex_h;
···
1197
1239
dy2 = y + srcrect->h/2;
1198
1240
}
1199
1241
1200
-
#ifdef SDL_GPU_USE_OPENGLv1
1201
-
1202
-
glBegin( GL_QUADS );
1203
-
//Bottom-left vertex (corner)
1204
-
glTexCoord2f( x1, y1 );
1205
-
glVertex3f( dx1, dy1, 0.0f );
1206
-
1207
-
//Bottom-right vertex (corner)
1208
-
glTexCoord2f( x2, y1 );
1209
-
glVertex3f( dx2, dy1, 0.0f );
1210
-
1211
-
//Top-right vertex (corner)
1212
-
glTexCoord2f( x2, y2 );
1213
-
glVertex3f( dx2, dy2, 0.0f );
1214
-
1215
-
//Top-left vertex (corner)
1216
-
glTexCoord2f( x1, y2 );
1217
-
glVertex3f( dx1, dy2, 0.0f );
1218
-
glEnd();
1219
-
#else
1220
-
1221
-
GLfloat gltexcoords[8];
1222
-
glTexCoordPointer(2, GL_FLOAT, 0, gltexcoords);
1223
-
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1224
-
1225
-
GLfloat glverts[12];
1226
-
glVertexPointer(3, GL_FLOAT, 0, glverts);
1227
-
glEnableClientState(GL_VERTEX_ARRAY);
1242
+
RendererData_OpenGL* rdata = (RendererData_OpenGL*)renderer->data;
1243
+
float* blit_buffer = rdata->blit_buffer;
1244
+
1245
+
if(rdata->blit_buffer_size + 6 >= rdata->blit_buffer_max_size)
1246
+
renderer->FlushBlitBuffer(renderer);
1247
+
1248
+
int vert_index = GPU_BLIT_BUFFER_VERTEX_OFFSET + rdata->blit_buffer_size*GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1249
+
int tex_index = GPU_BLIT_BUFFER_TEX_COORD_OFFSET + rdata->blit_buffer_size*GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1228
1250
1229
-
gltexcoords[0] = x1;
1230
-
gltexcoords[1] = y1;
1231
-
gltexcoords[2] = x2;
1232
-
gltexcoords[3] = y1;
1233
-
gltexcoords[4] = x2;
1234
-
gltexcoords[5] = y2;
1235
-
gltexcoords[6] = x1;
1236
-
gltexcoords[7] = y2;
1237
-
1238
-
glverts[0] = dx1;
1239
-
glverts[1] = dy1;
1240
-
glverts[2] = 0.0f;
1241
-
glverts[3] = dx2;
1242
-
glverts[4] = dy1;
1243
-
glverts[5] = 0.0f;
1244
-
glverts[6] = dx2;
1245
-
glverts[7] = dy2;
1246
-
glverts[8] = 0.0f;
1247
-
glverts[9] = dx1;
1248
-
glverts[10] = dy2;
1249
-
glverts[11] = 0.0f;
1250
-
1251
-
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1252
-
glDisableClientState(GL_VERTEX_ARRAY);
1253
-
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1254
-
#endif
1255
-
1256
-
if(dest->useClip)
1257
-
{
1258
-
glDisable(GL_SCISSOR_TEST);
1259
-
}
1260
-
1261
-
glMatrixMode( GL_PROJECTION );
1262
-
glPopMatrix();
1263
-
glMatrixMode( GL_MODELVIEW );
1264
-
1265
-
// restore viewport and projection
1266
-
if(renderer->display != dest)
1267
-
{
1268
-
glViewport(vp[0], vp[1], vp[2], vp[3]);
1251
+
blit_buffer[vert_index] = dx1;
1252
+
blit_buffer[vert_index+1] = dy1;
1253
+
blit_buffer[vert_index+2] = 0.0f;
1254
+
blit_buffer[tex_index] = x1;
1255
+
blit_buffer[tex_index+1] = y1;
1256
+
1257
+
vert_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1258
+
tex_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1259
+
blit_buffer[vert_index] = dx2;
1260
+
blit_buffer[vert_index+1] = dy1;
1261
+
blit_buffer[vert_index+2] = 0.0f;
1262
+
blit_buffer[tex_index] = x2;
1263
+
blit_buffer[tex_index+1] = y1;
1264
+
1265
+
vert_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1266
+
tex_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1267
+
blit_buffer[vert_index] = dx2;
1268
+
blit_buffer[vert_index+1] = dy2;
1269
+
blit_buffer[vert_index+2] = 0.0f;
1270
+
blit_buffer[tex_index] = x2;
1271
+
blit_buffer[tex_index+1] = y2;
1272
+
1273
+
1274
+
// Second tri
1275
+
1276
+
vert_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1277
+
tex_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1278
+
blit_buffer[vert_index] = dx1;
1279
+
blit_buffer[vert_index+1] = dy1;
1280
+
blit_buffer[vert_index+2] = 0.0f;
1281
+
blit_buffer[tex_index] = x1;
1282
+
blit_buffer[tex_index+1] = y1;
1283
+
1284
+
vert_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1285
+
tex_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1286
+
blit_buffer[vert_index] = dx2;
1287
+
blit_buffer[vert_index+1] = dy2;
1288
+
blit_buffer[vert_index+2] = 0.0f;
1289
+
blit_buffer[tex_index] = x2;
1290
+
blit_buffer[tex_index+1] = y2;
1291
+
1292
+
vert_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1293
+
tex_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1294
+
blit_buffer[vert_index] = dx1;
1295
+
blit_buffer[vert_index+1] = dy2;
1296
+
blit_buffer[vert_index+2] = 0.0f;
1297
+
blit_buffer[tex_index] = x1;
1298
+
blit_buffer[tex_index+1] = y2;
1299
+
1300
+
rdata->blit_buffer_size += 6;
1269
1301
1270
-
glMatrixMode( GL_PROJECTION );
1271
-
glPopMatrix();
1272
-
glMatrixMode( GL_MODELVIEW );
1273
-
}
1274
1302
return 0;
1275
1303
}
1276
1304
···
1279
1307
{
1280
1308
if(src == NULL || dest == NULL)
1281
1309
return -1;
1282
-
if(renderer != src->renderer || renderer != dest->renderer)
1283
-
return -2;
1284
-
1285
-
glPushMatrix();
1286
-
1287
-
glTranslatef(x, y, 0);
1288
-
glRotatef(angle, 0, 0, 1);
1289
-
1290
-
int result = GPU_Blit(src, srcrect, dest, 0, 0);
1291
-
1292
-
glPopMatrix();
1293
-
1294
-
return result;
1310
+
1311
+
return renderer->BlitTransformX(renderer, src, srcrect, dest, x, y, src->w/2, src->h/2, angle, 1.0f, 1.0f);
1295
1312
}
1296
1313
1297
1314
static int BlitScale(GPU_Renderer* renderer, GPU_Image* src, SDL_Rect* srcrect, GPU_Target* dest, float x, float y, float scaleX, float scaleY)
1298
1315
{
1299
1316
if(src == NULL || dest == NULL)
1300
1317
return -1;
1301
-
if(renderer != src->renderer || renderer != dest->renderer)
1302
-
return -2;
1303
-
1304
-
glPushMatrix();
1305
-
1306
-
glTranslatef(x, y, 0);
1307
-
glScalef(scaleX, scaleY, 1.0f);
1308
-
1309
-
int result = GPU_Blit(src, srcrect, dest, 0, 0);
1310
-
1311
-
glPopMatrix();
1312
-
1313
-
return result;
1318
+
1319
+
return renderer->BlitTransformX(renderer, src, srcrect, dest, x, y, src->w/2, src->h/2, 0.0f, scaleX, scaleY);
1314
1320
}
1315
1321
1316
1322
static int BlitTransform(GPU_Renderer* renderer, GPU_Image* src, SDL_Rect* srcrect, GPU_Target* dest, float x, float y, float angle, float scaleX, float scaleY)
1317
1323
{
1318
1324
if(src == NULL || dest == NULL)
1319
1325
return -1;
1320
-
if(renderer != src->renderer || renderer != dest->renderer)
1321
-
return -2;
1322
-
1323
-
glPushMatrix();
1324
-
1325
-
glTranslatef(x, y, 0);
1326
-
glRotatef(angle, 0, 0, 1);
1327
-
glScalef(scaleX, scaleY, 1.0f);
1328
-
1329
-
int result = GPU_Blit(src, srcrect, dest, 0, 0);
1330
-
1331
-
glPopMatrix();
1332
-
1333
-
return result;
1326
+
1327
+
return renderer->BlitTransformX(renderer, src, srcrect, dest, x, y, src->w/2, src->h/2, angle, scaleX, scaleY);
1334
1328
}
1335
1329
1336
1330
static int BlitTransformX(GPU_Renderer* renderer, GPU_Image* src, SDL_Rect* srcrect, GPU_Target* dest, float x, float y, float pivot_x, float pivot_y, float angle, float scaleX, float scaleY)
···
1340
1334
if(renderer != src->renderer || renderer != dest->renderer)
1341
1335
return -2;
1342
1336
1343
-
glPushMatrix();
1337
+
1338
+
// Bind the texture to which subsequent calls refer
1339
+
bindTexture(renderer, src);
1340
+
1341
+
// Bind the FBO
1342
+
bindFramebuffer(renderer, dest);
1343
+
1344
+
Uint16 tex_w = ((ImageData_OpenGL*)src->data)->tex_w;
1345
+
Uint16 tex_h = ((ImageData_OpenGL*)src->data)->tex_h;
1344
1346
1347
+
float x1, y1, x2, y2;
1348
+
/*
1349
+
1,1 --- 3,3
1350
+
| |
1351
+
| |
1352
+
4,4 --- 2,2
1353
+
*/
1354
+
float dx1, dy1, dx2, dy2, dx3, dy3, dx4, dy4;
1355
+
if(srcrect == NULL)
1356
+
{
1357
+
// Scale tex coords according to actual texture dims
1358
+
x1 = 0.1f/tex_w;
1359
+
y1 = 0.1f/tex_h;
1360
+
x2 = ((float)src->w - 0.1f)/tex_w;
1361
+
y2 = ((float)src->h - 0.1f)/tex_h;
1362
+
// Center the image on the given coords
1363
+
dx1 = -src->w/2;
1364
+
dy1 = -src->h/2;
1365
+
dx2 = src->w/2;
1366
+
dy2 = src->h/2;
1367
+
}
1368
+
else
1369
+
{
1370
+
// Scale srcrect tex coords according to actual texture dims
1371
+
x1 = (srcrect->x + 0.1f)/(float)tex_w;
1372
+
y1 = (srcrect->y + 0.1f)/(float)tex_h;
1373
+
x2 = (srcrect->x + srcrect->w - 0.1f)/(float)tex_w;
1374
+
y2 = (srcrect->y + srcrect->h - 0.1f)/(float)tex_h;
1375
+
// Center the image on the given coords
1376
+
dx1 = -srcrect->w/2;
1377
+
dy1 = -srcrect->h/2;
1378
+
dx2 = srcrect->w/2;
1379
+
dy2 = srcrect->h/2;
1380
+
}
1381
+
1382
+
// Apply transforms
1383
+
1384
+
// Scale
1385
+
if(scaleX != 1.0f || scaleY != 1.0f)
1386
+
{
1387
+
float w = (dx2 - dx1)*scaleX;
1388
+
float h = (dy2 - dy1)*scaleY;
1389
+
dx1 = (dx2 + dx1)/2 - w/2;
1390
+
dx2 = dx1 + w;
1391
+
dy1 = (dy2 + dy1)/2 - h/2;
1392
+
dy2 = dy1 + h;
1393
+
}
1394
+
1345
1395
// Shift away from the center (these are relative to the image corner)
1346
1396
pivot_x -= src->w/2;
1347
1397
pivot_y -= src->h/2;
1348
1398
1349
-
// Scale the pivot point so it moves the src image the right amount according to the viewport scale
1350
-
//pivot_x *= ?;
1351
-
//pivot_y *= ?;
1352
-
1353
-
glTranslatef(x, y, 0);
1354
-
glRotatef(angle, 0, 0, 1);
1355
-
glScalef(scaleX, scaleY, 1.0f);
1356
-
glTranslatef(-pivot_x, -pivot_y, 0);
1357
-
1358
-
int result = GPU_Blit(src, srcrect, dest, 0, 0);
1399
+
// Translate origin to pivot
1400
+
dx1 -= pivot_x*scaleX;
1401
+
dy1 -= pivot_y*scaleY;
1402
+
dx2 -= pivot_x*scaleX;
1403
+
dy2 -= pivot_y*scaleY;
1404
+
1405
+
// Get extra vertices for rotation
1406
+
dx3 = dx2;
1407
+
dy3 = dy1;
1408
+
dx4 = dx1;
1409
+
dy4 = dy2;
1410
+
1411
+
// Rotate about origin (the pivot)
1412
+
if(angle != 0.0f)
1413
+
{
1414
+
float cosA = cos(angle*M_PI/180);
1415
+
float sinA = sin(angle*M_PI/180);
1416
+
float tempX = dx1;
1417
+
dx1 = dx1*cosA - dy1*sinA;
1418
+
dy1 = tempX*sinA + dy1*cosA;
1419
+
tempX = dx2;
1420
+
dx2 = dx2*cosA - dy2*sinA;
1421
+
dy2 = tempX*sinA + dy2*cosA;
1422
+
tempX = dx3;
1423
+
dx3 = dx3*cosA - dy3*sinA;
1424
+
dy3 = tempX*sinA + dy3*cosA;
1425
+
tempX = dx4;
1426
+
dx4 = dx4*cosA - dy4*sinA;
1427
+
dy4 = tempX*sinA + dy4*cosA;
1428
+
}
1429
+
1430
+
// Translate to pos
1431
+
dx1 += x;
1432
+
dx2 += x;
1433
+
dx3 += x;
1434
+
dx4 += x;
1435
+
dy1 += y;
1436
+
dy2 += y;
1437
+
dy3 += y;
1438
+
dy4 += y;
1439
+
1440
+
RendererData_OpenGL* rdata = (RendererData_OpenGL*)renderer->data;
1441
+
float* blit_buffer = rdata->blit_buffer;
1442
+
1443
+
if(rdata->blit_buffer_size + 6 >= rdata->blit_buffer_max_size)
1444
+
renderer->FlushBlitBuffer(renderer);
1445
+
1446
+
int vert_index = GPU_BLIT_BUFFER_VERTEX_OFFSET + rdata->blit_buffer_size*GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1447
+
int tex_index = GPU_BLIT_BUFFER_TEX_COORD_OFFSET + rdata->blit_buffer_size*GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1359
1448
1360
-
glPopMatrix();
1449
+
blit_buffer[vert_index] = dx1;
1450
+
blit_buffer[vert_index+1] = dy1;
1451
+
blit_buffer[vert_index+2] = 0.0f;
1452
+
blit_buffer[tex_index] = x1;
1453
+
blit_buffer[tex_index+1] = y1;
1454
+
1455
+
vert_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1456
+
tex_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1457
+
blit_buffer[vert_index] = dx3;
1458
+
blit_buffer[vert_index+1] = dy3;
1459
+
blit_buffer[vert_index+2] = 0.0f;
1460
+
blit_buffer[tex_index] = x2;
1461
+
blit_buffer[tex_index+1] = y1;
1462
+
1463
+
vert_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1464
+
tex_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1465
+
blit_buffer[vert_index] = dx2;
1466
+
blit_buffer[vert_index+1] = dy2;
1467
+
blit_buffer[vert_index+2] = 0.0f;
1468
+
blit_buffer[tex_index] = x2;
1469
+
blit_buffer[tex_index+1] = y2;
1470
+
1471
+
1472
+
// Second tri
1473
+
1474
+
vert_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1475
+
tex_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1476
+
blit_buffer[vert_index] = dx1;
1477
+
blit_buffer[vert_index+1] = dy1;
1478
+
blit_buffer[vert_index+2] = 0.0f;
1479
+
blit_buffer[tex_index] = x1;
1480
+
blit_buffer[tex_index+1] = y1;
1481
+
1482
+
vert_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1483
+
tex_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1484
+
blit_buffer[vert_index] = dx2;
1485
+
blit_buffer[vert_index+1] = dy2;
1486
+
blit_buffer[vert_index+2] = 0.0f;
1487
+
blit_buffer[tex_index] = x2;
1488
+
blit_buffer[tex_index+1] = y2;
1489
+
1490
+
vert_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1491
+
tex_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
1492
+
blit_buffer[vert_index] = dx4;
1493
+
blit_buffer[vert_index+1] = dy4;
1494
+
blit_buffer[vert_index+2] = 0.0f;
1495
+
blit_buffer[tex_index] = x1;
1496
+
blit_buffer[tex_index+1] = y2;
1497
+
1498
+
rdata->blit_buffer_size += 6;
1361
1499
1362
-
return result;
1500
+
return 0;
1363
1501
}
1364
1502
1365
1503
static int BlitTransformMatrix(GPU_Renderer* renderer, GPU_Image* src, SDL_Rect* srcrect, GPU_Target* dest, float x, float y, float* matrix3x3)
···
1410
1548
if(image == NULL)
1411
1549
return;
1412
1550
1413
-
bindTexture( renderer, ((ImageData_OpenGL*)image->data)->handle );
1551
+
if(image->target != NULL)
1552
+
flushBlitBufferIfCurrentFramebuffer(renderer, image->target);
1553
+
bindTexture(renderer, image);
1414
1554
glGenerateMipmap(GL_TEXTURE_2D);
1415
1555
((ImageData_OpenGL*)image->data)->hasMipmaps = 1;
1416
1556
···
1422
1562
1423
1563
1424
1564
1565
+
1566
+
static SDL_Rect SetClip(GPU_Renderer* renderer, GPU_Target* target, Sint16 x, Sint16 y, Uint16 w, Uint16 h)
1567
+
{
1568
+
if(target == NULL)
1569
+
{
1570
+
SDL_Rect r = {0,0,0,0};
1571
+
return r;
1572
+
}
1573
+
1574
+
flushBlitBufferIfCurrentFramebuffer(renderer, target);
1575
+
target->useClip = 1;
1576
+
1577
+
SDL_Rect r = target->clipRect;
1578
+
1579
+
target->clipRect.x = x;
1580
+
target->clipRect.y = y;
1581
+
target->clipRect.w = w;
1582
+
target->clipRect.h = h;
1583
+
1584
+
return r;
1585
+
}
1586
+
1587
+
static void ClearClip(GPU_Renderer* renderer, GPU_Target* target)
1588
+
{
1589
+
if(target == NULL)
1590
+
return;
1591
+
1592
+
flushBlitBufferIfCurrentFramebuffer(renderer, target);
1593
+
target->useClip = 0;
1594
+
target->clipRect.x = 0;
1595
+
target->clipRect.y = 0;
1596
+
target->clipRect.w = target->w;
1597
+
target->clipRect.h = target->h;
1598
+
}
1599
+
1600
+
1601
+
1602
+
1425
1603
static Uint8 GetBlending(GPU_Renderer* renderer)
1426
1604
{
1427
1605
return ((RendererData_OpenGL*)renderer->data)->blending;
···
1431
1609
1432
1610
static void SetBlending(GPU_Renderer* renderer, Uint8 enable)
1433
1611
{
1612
+
renderer->FlushBlitBuffer(renderer);
1613
+
1434
1614
if(enable)
1435
1615
glEnable(GL_BLEND);
1436
1616
else
···
1442
1622
1443
1623
static void SetRGBA(GPU_Renderer* renderer, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
1444
1624
{
1625
+
renderer->FlushBlitBuffer(renderer);
1445
1626
glColor4f(r/255.01f, g/255.01f, b/255.01f, a/255.01f);
1446
1627
}
1447
1628
···
1453
1634
if(renderer != image->renderer)
1454
1635
return;
1455
1636
1456
-
bindTexture( renderer, ((ImageData_OpenGL*)image->data)->handle );
1637
+
if(image->target != NULL)
1638
+
flushBlitBufferIfCurrentFramebuffer(renderer, image->target);
1639
+
bindTexture(renderer, image);
1457
1640
1458
1641
GLint textureWidth, textureHeight;
1459
1642
···
1497
1680
if(renderer != image->renderer)
1498
1681
return;
1499
1682
1500
-
bindTexture( renderer, ((ImageData_OpenGL*)image->data)->handle );
1683
+
if(image->target != NULL)
1684
+
flushBlitBufferIfCurrentFramebuffer(renderer, image->target);
1685
+
bindTexture(renderer, image);
1501
1686
1502
1687
GLint textureWidth, textureHeight;
1503
1688
···
1634
1819
return;
1635
1820
if(renderer != image->renderer)
1636
1821
return;
1637
-
1638
-
bindTexture( renderer, ((ImageData_OpenGL*)image->data)->handle );
1822
+
1823
+
if(image->target != NULL)
1824
+
flushBlitBufferIfCurrentFramebuffer(renderer, image->target);
1825
+
bindTexture(renderer, image);
1639
1826
1640
1827
GLint textureWidth, textureHeight;
1641
1828
···
1701
1888
if(renderer != image->renderer)
1702
1889
return;
1703
1890
1704
-
bindTexture( renderer, ((ImageData_OpenGL*)image->data)->handle );
1891
+
if(image->target != NULL)
1892
+
flushBlitBufferIfCurrentFramebuffer(renderer, image->target);
1893
+
bindTexture(renderer, image);
1705
1894
1706
1895
GLint textureWidth, textureHeight;
1707
1896
···
1779
1968
if(x < 0 || y < 0 || x >= target->w || y >= target->h)
1780
1969
return result;
1781
1970
1782
-
bindFramebuffer(renderer, ((TargetData_OpenGL*)target->data)->handle);
1971
+
flushBlitBufferIfCurrentFramebuffer(renderer, target);
1972
+
bindFramebuffer(renderer, target);
1783
1973
1784
1974
unsigned char pixels[4];
1785
1975
glReadPixels(x, y, 1, 1, ((TargetData_OpenGL*)target->data)->format, GL_UNSIGNED_BYTE, pixels);
···
1799
1989
if(renderer != image->renderer)
1800
1990
return;
1801
1991
1802
-
bindTexture( renderer, ((ImageData_OpenGL*)image->data)->handle );
1992
+
bindTexture(renderer, image);
1803
1993
1804
1994
GLenum minFilter = GL_NEAREST;
1805
1995
GLenum magFilter = GL_NEAREST;
···
1830
2020
1831
2021
static void SetBlendMode(GPU_Renderer* renderer, GPU_BlendEnum mode)
1832
2022
{
2023
+
renderer->FlushBlitBuffer(renderer);
2024
+
1833
2025
if(mode == GPU_BLEND_NORMAL)
1834
2026
{
1835
2027
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
···
1901
2093
if(renderer != target->renderer)
1902
2094
return;
1903
2095
1904
-
bindFramebuffer(renderer, ((TargetData_OpenGL*)target->data)->handle);
2096
+
flushBlitBufferIfCurrentFramebuffer(renderer, target);
2097
+
bindFramebuffer(renderer, target);
1905
2098
SDL_Rect viewport = getViewport();
1906
2099
glViewport(0,0,target->w, target->h);
1907
2100
···
1937
2130
if(renderer != target->renderer)
1938
2131
return;
1939
2132
1940
-
bindFramebuffer(renderer, ((TargetData_OpenGL*)target->data)->handle);
2133
+
flushBlitBufferIfCurrentFramebuffer(renderer, target);
2134
+
bindFramebuffer(renderer, target);
1941
2135
1942
2136
SDL_Rect viewport = getViewport();
1943
2137
glViewport(0,0,target->w, target->h);
···
1964
2158
setViewport(viewport);
1965
2159
}
1966
2160
2161
+
static void FlushBlitBuffer(GPU_Renderer* renderer)
2162
+
{
2163
+
RendererData_OpenGL* rdata = (RendererData_OpenGL*)renderer->data;
2164
+
if(rdata->blit_buffer_size > 0 && rdata->last_target != NULL && rdata->last_image != NULL)
2165
+
{
2166
+
Uint8 isRTT = (renderer->display != rdata->last_target);
2167
+
2168
+
glEnable(GL_TEXTURE_2D);
2169
+
GPU_Target* dest = rdata->last_target;
2170
+
2171
+
// Modify the viewport and projection matrix if rendering to a texture
2172
+
GLint vp[4];
2173
+
if(isRTT)
2174
+
{
2175
+
glGetIntegerv(GL_VIEWPORT, vp);
2176
+
2177
+
unsigned int w = dest->w;
2178
+
unsigned int h = dest->h;
2179
+
2180
+
glViewport( 0, 0, w, h);
2181
+
2182
+
glMatrixMode( GL_PROJECTION );
2183
+
glPushMatrix();
2184
+
glLoadIdentity();
2185
+
2186
+
glOrtho(0.0f, w, 0.0f, h, -1.0f, 1.0f); // Special inverted orthographic projection because tex coords are inverted already.
2187
+
2188
+
glMatrixMode( GL_MODELVIEW );
2189
+
}
2190
+
2191
+
2192
+
if(dest->useClip)
2193
+
{
2194
+
glEnable(GL_SCISSOR_TEST);
2195
+
int y = (renderer->display == dest? renderer->display->h - (dest->clipRect.y + dest->clipRect.h) : dest->clipRect.y);
2196
+
float xFactor = ((float)renderer->window_w)/renderer->display->w;
2197
+
float yFactor = ((float)renderer->window_h)/renderer->display->h;
2198
+
glScissor(dest->clipRect.x * xFactor, y * yFactor, dest->clipRect.w * xFactor, dest->clipRect.h * yFactor);
2199
+
}
2200
+
2201
+
2202
+
2203
+
#ifdef SDL_GPU_USE_OPENGLv1
2204
+
2205
+
float* vertex_pointer = rdata->blit_buffer + GPU_BLIT_BUFFER_VERTEX_OFFSET;
2206
+
float* texcoord_pointer = rdata->blit_buffer + GPU_BLIT_BUFFER_TEX_COORD_OFFSET;
2207
+
int i;
2208
+
for(i = 0; i < rdata->blit_buffer_size; i++)
2209
+
{
2210
+
glBegin( GL_TRIANGLES );
2211
+
2212
+
glTexCoord2f( *texcoord_pointer, *(texcoord_pointer+1) );
2213
+
glVertex3f( *vertex_pointer, *(vertex_pointer+1), *(vertex_pointer+2) );
2214
+
texcoord_pointer += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
2215
+
vertex_pointer += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
2216
+
2217
+
glTexCoord2f( *texcoord_pointer, *(texcoord_pointer+1) );
2218
+
glVertex3f( *vertex_pointer, *(vertex_pointer+1), *(vertex_pointer+2) );
2219
+
texcoord_pointer += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
2220
+
vertex_pointer += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
2221
+
2222
+
glTexCoord2f( *texcoord_pointer, *(texcoord_pointer+1) );
2223
+
glVertex3f( *vertex_pointer, *(vertex_pointer+1), *(vertex_pointer+2) );
2224
+
texcoord_pointer += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
2225
+
vertex_pointer += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
2226
+
2227
+
glTexCoord2f( *texcoord_pointer, *(texcoord_pointer+1) );
2228
+
glVertex3f( *vertex_pointer, *(vertex_pointer+1), *(vertex_pointer+2) );
2229
+
texcoord_pointer += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
2230
+
vertex_pointer += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
2231
+
2232
+
glTexCoord2f( *texcoord_pointer, *(texcoord_pointer+1) );
2233
+
glVertex3f( *vertex_pointer, *(vertex_pointer+1), *(vertex_pointer+2) );
2234
+
texcoord_pointer += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
2235
+
vertex_pointer += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
2236
+
2237
+
glTexCoord2f( *texcoord_pointer, *(texcoord_pointer+1) );
2238
+
glVertex3f( *vertex_pointer, *(vertex_pointer+1), *(vertex_pointer+2) );
2239
+
texcoord_pointer += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
2240
+
vertex_pointer += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX;
2241
+
2242
+
glEnd();
2243
+
}
2244
+
#else
2245
+
2246
+
glEnableClientState(GL_VERTEX_ARRAY);
2247
+
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
2248
+
glVertexPointer(3, GL_FLOAT, GPU_BLIT_BUFFER_STRIDE, rdata->blit_buffer + GPU_BLIT_BUFFER_VERTEX_OFFSET);
2249
+
glTexCoordPointer(2, GL_FLOAT, GPU_BLIT_BUFFER_STRIDE, rdata->blit_buffer + GPU_BLIT_BUFFER_TEX_COORD_OFFSET);
2250
+
2251
+
glDrawArrays(GL_TRIANGLES, 0, rdata->blit_buffer_size);
2252
+
2253
+
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
2254
+
glDisableClientState(GL_VERTEX_ARRAY);
2255
+
2256
+
#endif
2257
+
2258
+
rdata->blit_buffer_size = 0;
2259
+
2260
+
if(dest->useClip)
2261
+
{
2262
+
glDisable(GL_SCISSOR_TEST);
2263
+
}
2264
+
2265
+
glMatrixMode( GL_PROJECTION );
2266
+
glPopMatrix();
2267
+
glMatrixMode( GL_MODELVIEW );
2268
+
2269
+
// restore viewport and projection
2270
+
if(isRTT)
2271
+
{
2272
+
glViewport(vp[0], vp[1], vp[2], vp[3]);
2273
+
2274
+
glMatrixMode( GL_PROJECTION );
2275
+
glPopMatrix();
2276
+
glMatrixMode( GL_MODELVIEW );
2277
+
}
2278
+
2279
+
}
2280
+
}
2281
+
1967
2282
static void Flip(GPU_Renderer* renderer)
1968
2283
{
2284
+
renderer->FlushBlitBuffer(renderer);
2285
+
1969
2286
#ifdef SDL_GPU_USE_SDL2
1970
2287
SDL_GL_SwapWindow(((RendererData_OpenGL*)renderer->data)->window);
1971
2288
#else
···
2025
2342
renderer->GetZ = &GetZ;
2026
2343
renderer->GenerateMipmaps = &GenerateMipmaps;
2027
2344
2345
+
renderer->SetClip = &SetClip;
2346
+
renderer->ClearClip = &ClearClip;
2028
2347
renderer->GetBlending = &GetBlending;
2029
2348
renderer->SetBlending = &SetBlending;
2030
2349
renderer->SetRGBA = &SetRGBA;
···
2039
2358
2040
2359
renderer->Clear = &Clear;
2041
2360
renderer->ClearRGBA = &ClearRGBA;
2361
+
renderer->FlushBlitBuffer = &FlushBlitBuffer;
2042
2362
renderer->Flip = &Flip;
2043
2363
2044
2364
return renderer;
+10
-5
SDL_gpu/OpenGL_common/SDL_gpu_OpenGL.h
+10
-5
SDL_gpu/OpenGL_common/SDL_gpu_OpenGL.h
···
30
30
#define GL_FUNC_REVERSE_SUBTRACT GL_FUNC_REVERSE_SUBTRACT_OES
31
31
#endif
32
32
33
-
#define GPU_BLIT_BUFFER_STRIDE (sizeof(float)*5)
33
+
// Forces a flush when limit is reached (roughly 1000 sprites)
34
+
#define GPU_BLIT_BUFFER_INIT_MAX_SIZE 6000
35
+
// x, y, z, s, t
36
+
#define GPU_BLIT_BUFFER_FLOATS_PER_VERTEX 5
37
+
// bytes per vertex
38
+
#define GPU_BLIT_BUFFER_STRIDE (sizeof(float)*GPU_BLIT_BUFFER_FLOATS_PER_VERTEX)
34
39
#define GPU_BLIT_BUFFER_VERTEX_OFFSET 0
35
40
#define GPU_BLIT_BUFFER_TEX_COORD_OFFSET 3
36
41
···
44
49
float z;
45
50
Uint8 blending;
46
51
47
-
GLuint last_texture;
48
-
GLuint last_framebuffer;
49
-
/*float* blit_buffer; // Holds sets of 4 vertices and 4 tex coords interleaved (e.g. [x0, y0, z0, s0, t0, ...]).
52
+
GPU_Image* last_image;
53
+
GPU_Target* last_target;
54
+
float* blit_buffer; // Holds sets of 4 vertices and 4 tex coords interleaved (e.g. [x0, y0, z0, s0, t0, ...]).
50
55
int blit_buffer_size;
51
-
int blit_buffer_max_size;*/
56
+
int blit_buffer_max_size;
52
57
} RendererData_OpenGL;
53
58
54
59
typedef struct ImageData_OpenGL
+15
-26
SDL_gpu/SDL_gpu.c
+15
-26
SDL_gpu/SDL_gpu.c
···
465
465
466
466
SDL_Rect GPU_SetClipRect(GPU_Target* target, SDL_Rect rect)
467
467
{
468
-
if(target == NULL)
468
+
if(target == NULL || current_renderer == NULL || current_renderer->SetClip == NULL)
469
469
{
470
470
SDL_Rect r = {0,0,0,0};
471
471
return r;
472
472
}
473
473
474
-
target->useClip = 1;
475
-
476
-
SDL_Rect r = target->clipRect;
477
-
478
-
target->clipRect = rect;
479
-
480
-
return r;
474
+
return current_renderer->SetClip(current_renderer, target, rect.x, rect.y, rect.w, rect.h);
481
475
}
482
476
483
477
SDL_Rect GPU_SetClip(GPU_Target* target, Sint16 x, Sint16 y, Uint16 w, Uint16 h)
484
478
{
485
-
if(target == NULL)
479
+
if(target == NULL || current_renderer == NULL || current_renderer->SetClip == NULL)
486
480
{
487
481
SDL_Rect r = {0,0,0,0};
488
482
return r;
489
483
}
490
484
491
-
target->useClip = 1;
492
-
493
-
SDL_Rect r = target->clipRect;
494
-
495
-
target->clipRect.x = x;
496
-
target->clipRect.y = y;
497
-
target->clipRect.w = w;
498
-
target->clipRect.h = h;
499
-
500
-
return r;
485
+
return current_renderer->SetClip(current_renderer, target, x, y, w, h);
501
486
}
502
487
503
488
void GPU_ClearClip(GPU_Target* target)
504
489
{
505
-
if(target == NULL)
506
-
return;
490
+
if(target == NULL || current_renderer == NULL || current_renderer->ClearClip == NULL)
491
+
return;
507
492
508
-
target->useClip = 0;
509
-
target->clipRect.x = 0;
510
-
target->clipRect.y = 0;
511
-
target->clipRect.w = target->w;
512
-
target->clipRect.h = target->h;
493
+
current_renderer->ClearClip(current_renderer, target);
513
494
}
514
495
515
496
···
641
622
return;
642
623
643
624
current_renderer->ClearRGBA(current_renderer, target, r, g, b, a);
625
+
}
626
+
627
+
void GPU_FlushBlitBuffer(void)
628
+
{
629
+
if(current_renderer == NULL || current_renderer->FlushBlitBuffer == NULL)
630
+
return;
631
+
632
+
current_renderer->FlushBlitBuffer(current_renderer);
644
633
}
645
634
646
635
void GPU_Flip(void)
+11
SDL_gpu/SDL_gpu.h
+11
SDL_gpu/SDL_gpu.h
···
191
191
/*! \see GPU_GenerateMipmaps() */
192
192
void (*GenerateMipmaps)(GPU_Renderer* renderer, GPU_Image* image);
193
193
194
+
/*! \see GPU_SetClip() */
195
+
SDL_Rect (*SetClip)(GPU_Renderer* renderer, GPU_Target* target, Sint16 x, Sint16 y, Uint16 w, Uint16 h);
196
+
197
+
/*! \see GPU_ClearClip() */
198
+
void (*ClearClip)(GPU_Renderer* renderer, GPU_Target* target);
199
+
194
200
/*! \see GPU_GetBlending() */
195
201
Uint8 (*GetBlending)(GPU_Renderer* renderer);
196
202
···
225
231
void (*Clear)(GPU_Renderer* renderer, GPU_Target* target);
226
232
/*! \see GPU_ClearRGBA() */
227
233
void (*ClearRGBA)(GPU_Renderer* renderer, GPU_Target* target, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
234
+
/*! \see GPU_FlushBlitBuffer() */
235
+
void (*FlushBlitBuffer)(GPU_Renderer* renderer);
228
236
/*! \see GPU_Flip() */
229
237
void (*Flip)(GPU_Renderer* renderer);
230
238
···
480
488
481
489
/*! Fills the given render target with a color. */
482
490
void GPU_ClearRGBA(GPU_Target* target, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
491
+
492
+
/*! Send all buffered blitting data to the last target. */
493
+
void GPU_FlushBlitBuffer(void);
483
494
484
495
/*! Updates the physical display (monitor) with the contents of the display surface/framebuffer. */
485
496
void GPU_Flip(void);
+1
SDL_gpu/SDL_gpu_Renderer.c
+1
SDL_gpu/SDL_gpu_Renderer.c
demos/data/small_test.png
demos/data/small_test.png
This is a binary file and will not be displayed.
+7
-3
demos/sprite-stress/main.c
+7
-3
demos/sprite-stress/main.c
···
24
24
25
25
printf("Using renderer: %s\n", GPU_GetCurrentRendererID());
26
26
27
-
GPU_Image* image = GPU_LoadImage("data/test3.png");
27
+
GPU_Image* image = GPU_LoadImage("data/small_test.png");
28
28
if(image == NULL)
29
29
return -1;
30
30
···
67
67
{
68
68
if(numSprites < maxSprites)
69
69
numSprites += 100;
70
-
GPU_LogError("Sprites: %d\n", numSprites);
70
+
GPU_LogError("Sprites: %d\n", numSprites);
71
+
frameCount = 0;
72
+
startTime = SDL_GetTicks();
71
73
}
72
74
else if(event.key.keysym.sym == SDLK_MINUS)
73
75
{
···
75
77
numSprites -= 100;
76
78
if(numSprites < 1)
77
79
numSprites = 1;
78
-
GPU_LogError("Sprites: %d\n", numSprites);
80
+
GPU_LogError("Sprites: %d\n", numSprites);
81
+
frameCount = 0;
82
+
startTime = SDL_GetTicks();
79
83
}
80
84
}
81
85
}