this repo has no description
Moved NULL context target checks into the SDL_gpu.c layer.
+72
-95
+7
-30
SDL_gpu/GL_common/SDL_gpu_GL_common.inl
+7
-30
SDL_gpu/GL_common/SDL_gpu_GL_common.inl
···
1101
1101
1102
1102
static int SetWindowResolution(GPU_Renderer* renderer, Uint16 w, Uint16 h)
1103
1103
{
1104
-
if(renderer->current_context_target == NULL)
1105
-
return 0;
1106
-
1107
1104
#ifdef SDL_GPU_USE_SDL2
1108
1105
SDL_SetWindowSize(SDL_GetWindowFromID(renderer->current_context_target->context->windowID), w, h);
1109
1106
SDL_GetWindowSize(SDL_GetWindowFromID(renderer->current_context_target->context->windowID), &renderer->current_context_target->context->window_w, &renderer->current_context_target->context->window_h);
···
1177
1174
static int ToggleFullscreen(GPU_Renderer* renderer)
1178
1175
{
1179
1176
#ifdef SDL_GPU_USE_SDL2
1180
-
if(renderer->current_context_target == NULL)
1181
-
return 0;
1182
-
1183
1177
Uint8 enable = !(SDL_GetWindowFlags(SDL_GetWindowFromID(renderer->current_context_target->context->windowID)) & SDL_WINDOW_FULLSCREEN);
1184
1178
1185
1179
if(SDL_SetWindowFullscreen(SDL_GetWindowFromID(renderer->current_context_target->context->windowID), enable) < 0)
···
1202
1196
1203
1197
static GPU_Camera SetCamera(GPU_Renderer* renderer, GPU_Target* target, GPU_Camera* cam)
1204
1198
{
1205
-
if(target == NULL || renderer->current_context_target == NULL)
1199
+
if(target == NULL)
1206
1200
return GPU_GetDefaultCamera();
1207
1201
1208
1202
···
1905
1899
// From SDL_UpdateTexture()
1906
1900
static int InitImageWithSurface(GPU_Renderer* renderer, GPU_Image* image, SDL_Surface* surface)
1907
1901
{
1908
-
if(renderer == NULL || image == NULL || surface == NULL)
1902
+
if(image == NULL || surface == NULL)
1909
1903
return 0;
1910
1904
1911
1905
IMAGE_DATA* data = (IMAGE_DATA*)image->data;
···
2001
1995
// From SDL_UpdateTexture()
2002
1996
static void UpdateImage(GPU_Renderer* renderer, GPU_Image* image, const GPU_Rect* rect, SDL_Surface* surface)
2003
1997
{
2004
-
if(renderer == NULL || image == NULL || surface == NULL)
1998
+
if(image == NULL || surface == NULL)
2005
1999
return;
2006
2000
2007
2001
IMAGE_DATA* data = (IMAGE_DATA*)image->data;
···
2098
2092
GPU_Image* image;
2099
2093
int channels;
2100
2094
2101
-
if(renderer == NULL)
2102
-
return NULL;
2103
-
2104
2095
if (!surface) {
2105
2096
GPU_LogError("GPU_CopyImageFromSurface() passed NULL surface.\n");
2106
2097
return NULL;
···
2184
2175
2185
2176
static void SubSurfaceCopy(GPU_Renderer* renderer, SDL_Surface* src, GPU_Rect* srcrect, GPU_Target* dest, Sint16 x, Sint16 y)
2186
2177
{
2187
-
if(renderer == NULL || src == NULL || dest == NULL || dest->image == NULL)
2178
+
if(src == NULL || dest == NULL || dest->image == NULL)
2188
2179
return;
2189
2180
2190
2181
if(renderer != dest->renderer)
···
2263
2254
2264
2255
static GPU_Target* LoadTarget(GPU_Renderer* renderer, GPU_Image* image)
2265
2256
{
2266
-
if(renderer == NULL || image == NULL)
2257
+
if(image == NULL)
2267
2258
return NULL;
2268
2259
2269
2260
if(image->target != NULL)
···
2545
2536
2546
2537
2547
2538
makeContextCurrent(renderer, dest);
2548
-
if(renderer->current_context_target == NULL)
2549
-
return -3;
2550
2539
2551
2540
// Bind the texture to which subsequent calls refer
2552
2541
bindTexture(renderer, src);
···
2792
2781
return -2;
2793
2782
2794
2783
makeContextCurrent(renderer, dest);
2795
-
if(renderer->current_context_target == NULL)
2796
-
return -3;
2797
2784
2798
2785
// Bind the texture to which subsequent calls refer
2799
2786
bindTexture(renderer, src);
···
3005
2992
#endif
3006
2993
3007
2994
makeContextCurrent(renderer, dest);
3008
-
if(renderer->current_context_target == NULL)
3009
-
return -3;
3010
2995
3011
2996
// Bind the texture to which subsequent calls refer
3012
2997
bindTexture(renderer, src);
···
3529
3514
makeContextCurrent(renderer, target);
3530
3515
3531
3516
#ifdef SDL_GPU_USE_SDL2
3532
-
if(renderer->current_context_target == NULL)
3533
-
return;
3534
3517
SDL_GL_SwapWindow(SDL_GetWindowFromID(renderer->current_context_target->context->windowID));
3535
3518
#else
3536
3519
SDL_GL_SwapBuffers();
···
3708
3691
{
3709
3692
GPU_Target* target = renderer->current_context_target;
3710
3693
#ifndef SDL_GPU_DISABLE_SHADERS
3711
-
if(target == NULL)
3712
-
return;
3713
3694
3714
3695
if(program_object == 0) // Implies default shader
3715
3696
{
···
3721
3702
program_object = target->context->default_untextured_shader_program;
3722
3703
}
3723
3704
3724
-
if(target == NULL || target->context->current_shader_program == program_object)
3705
+
if(target->context->current_shader_program == program_object)
3725
3706
return;
3726
3707
3727
3708
renderer->FlushBlitBuffer(renderer);
···
3812
3793
static void SetShaderBlock(GPU_Renderer* renderer, GPU_ShaderBlock block)
3813
3794
{
3814
3795
#ifdef SDL_GPU_USE_GL_TIER3
3815
-
GPU_Target* target = renderer->current_context_target;
3816
-
if(target == NULL)
3817
-
return;
3818
-
TARGET_DATA* data = ((TARGET_DATA*)target->data);
3819
-
data->current_shader_block = block;
3796
+
((TARGET_DATA*)renderer->current_context_target->data)->current_shader_block = block;
3820
3797
#endif
3821
3798
}
3822
3799
+65
-65
SDL_gpu/SDL_gpu.c
+65
-65
SDL_gpu/SDL_gpu.c
···
119
119
120
120
Uint8 GPU_IsFeatureEnabled(GPU_FeatureEnum feature)
121
121
{
122
-
if(current_renderer == NULL || current_renderer->IsFeatureEnabled == NULL)
122
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->IsFeatureEnabled == NULL)
123
123
return 0;
124
124
125
125
return current_renderer->IsFeatureEnabled(current_renderer, feature);
···
127
127
128
128
GPU_Target* GPU_CreateTargetFromWindow(Uint32 windowID)
129
129
{
130
-
if(current_renderer == NULL || current_renderer->CreateTargetFromWindow == NULL)
130
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->CreateTargetFromWindow == NULL)
131
131
return NULL;
132
132
133
133
return current_renderer->CreateTargetFromWindow(current_renderer, windowID, NULL);
···
135
135
136
136
void GPU_MakeCurrent(GPU_Target* target, Uint32 windowID)
137
137
{
138
-
if(current_renderer == NULL || current_renderer->MakeCurrent == NULL)
138
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->MakeCurrent == NULL)
139
139
return;
140
140
141
141
current_renderer->MakeCurrent(current_renderer, target, windowID);
···
143
143
144
144
int GPU_ToggleFullscreen(void)
145
145
{
146
-
if(current_renderer == NULL || current_renderer->ToggleFullscreen == NULL)
146
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->ToggleFullscreen == NULL)
147
147
return 0;
148
148
149
149
return current_renderer->ToggleFullscreen(current_renderer);
···
151
151
152
152
int GPU_SetWindowResolution(Uint16 w, Uint16 h)
153
153
{
154
-
if(current_renderer == NULL || current_renderer->SetWindowResolution == NULL || w == 0 || h == 0)
154
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->SetWindowResolution == NULL || w == 0 || h == 0)
155
155
return 0;
156
156
157
157
return current_renderer->SetWindowResolution(current_renderer, w, h);
···
160
160
161
161
void GPU_SetVirtualResolution(GPU_Target* target, Uint16 w, Uint16 h)
162
162
{
163
-
if(current_renderer == NULL || current_renderer->SetVirtualResolution == NULL || w == 0 || h == 0)
163
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->SetVirtualResolution == NULL || w == 0 || h == 0)
164
164
return;
165
165
166
166
current_renderer->SetVirtualResolution(current_renderer, target, w, h);
···
267
267
268
268
GPU_Camera GPU_SetCamera(GPU_Target* target, GPU_Camera* cam)
269
269
{
270
-
if(current_renderer == NULL || current_renderer->SetCamera == NULL)
270
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->SetCamera == NULL)
271
271
return GPU_GetDefaultCamera();
272
272
273
273
return current_renderer->SetCamera(current_renderer, target, cam);
···
275
275
276
276
GPU_Image* GPU_CreateImage(Uint16 w, Uint16 h, Uint8 channels)
277
277
{
278
-
if(current_renderer == NULL || current_renderer->CreateImage == NULL)
278
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->CreateImage == NULL)
279
279
return NULL;
280
280
281
281
return current_renderer->CreateImage(current_renderer, w, h, channels);
···
283
283
284
284
GPU_Image* GPU_LoadImage(const char* filename)
285
285
{
286
-
if(current_renderer == NULL || current_renderer->LoadImage == NULL)
286
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->LoadImage == NULL)
287
287
return NULL;
288
288
289
289
return current_renderer->LoadImage(current_renderer, filename);
···
291
291
292
292
Uint8 GPU_SaveImage(GPU_Image* image, const char* filename)
293
293
{
294
-
if(current_renderer == NULL || current_renderer->SaveImage == NULL)
294
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->SaveImage == NULL)
295
295
return 0;
296
296
297
297
return current_renderer->SaveImage(current_renderer, image, filename);
···
299
299
300
300
GPU_Image* GPU_CopyImage(GPU_Image* image)
301
301
{
302
-
if(current_renderer == NULL || current_renderer->CopyImage == NULL)
302
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->CopyImage == NULL)
303
303
return NULL;
304
304
305
305
return current_renderer->CopyImage(current_renderer, image);
···
307
307
308
308
void GPU_UpdateImage(GPU_Image* image, const GPU_Rect* rect, SDL_Surface* surface)
309
309
{
310
-
if(current_renderer == NULL || current_renderer->UpdateImage == NULL)
310
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->UpdateImage == NULL)
311
311
return;
312
312
313
313
current_renderer->UpdateImage(current_renderer, image, rect, surface);
···
431
431
432
432
GPU_Image* GPU_CopyImageFromSurface(SDL_Surface* surface)
433
433
{
434
-
if(current_renderer == NULL || current_renderer->CopyImageFromSurface == NULL)
434
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->CopyImageFromSurface == NULL)
435
435
return NULL;
436
436
437
437
return current_renderer->CopyImageFromSurface(current_renderer, surface);
···
439
439
440
440
GPU_Image* GPU_CopyImageFromTarget(GPU_Target* target)
441
441
{
442
-
if(current_renderer == NULL || current_renderer->CopyImageFromTarget == NULL)
442
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->CopyImageFromTarget == NULL)
443
443
return NULL;
444
444
445
445
return current_renderer->CopyImageFromTarget(current_renderer, target);
···
447
447
448
448
SDL_Surface* GPU_CopySurfaceFromTarget(GPU_Target* target)
449
449
{
450
-
if(current_renderer == NULL || current_renderer->CopySurfaceFromTarget == NULL)
450
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->CopySurfaceFromTarget == NULL)
451
451
return NULL;
452
452
453
453
return current_renderer->CopySurfaceFromTarget(current_renderer, target);
···
455
455
456
456
SDL_Surface* GPU_CopySurfaceFromImage(GPU_Image* image)
457
457
{
458
-
if(current_renderer == NULL || current_renderer->CopySurfaceFromImage == NULL)
458
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->CopySurfaceFromImage == NULL)
459
459
return NULL;
460
460
461
461
return current_renderer->CopySurfaceFromImage(current_renderer, image);
···
463
463
464
464
void GPU_FreeImage(GPU_Image* image)
465
465
{
466
-
if(current_renderer == NULL || current_renderer->FreeImage == NULL)
466
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->FreeImage == NULL)
467
467
return;
468
468
469
469
current_renderer->FreeImage(current_renderer, image);
···
472
472
473
473
void GPU_SubSurfaceCopy(SDL_Surface* src, GPU_Rect* srcrect, GPU_Target* dest, Sint16 x, Sint16 y)
474
474
{
475
-
if(current_renderer == NULL || current_renderer->SubSurfaceCopy == NULL)
475
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->SubSurfaceCopy == NULL)
476
476
return;
477
477
478
478
current_renderer->SubSurfaceCopy(current_renderer, src, srcrect, dest, x, y);
···
489
489
490
490
GPU_Target* GPU_LoadTarget(GPU_Image* image)
491
491
{
492
-
if(current_renderer == NULL || current_renderer->LoadTarget == NULL)
492
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->LoadTarget == NULL)
493
493
return NULL;
494
494
495
495
return current_renderer->LoadTarget(current_renderer, image);
···
499
499
500
500
void GPU_FreeTarget(GPU_Target* target)
501
501
{
502
-
if(current_renderer == NULL || current_renderer->FreeTarget == NULL)
502
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->FreeTarget == NULL)
503
503
return;
504
504
505
505
current_renderer->FreeTarget(current_renderer, target);
···
509
509
510
510
int GPU_Blit(GPU_Image* src, GPU_Rect* srcrect, GPU_Target* dest, float x, float y)
511
511
{
512
-
if(current_renderer == NULL || current_renderer->Blit == NULL)
512
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->Blit == NULL)
513
513
return -2;
514
514
515
515
return current_renderer->Blit(current_renderer, src, srcrect, dest, x, y);
···
518
518
519
519
int GPU_BlitRotate(GPU_Image* src, GPU_Rect* srcrect, GPU_Target* dest, float x, float y, float angle)
520
520
{
521
-
if(current_renderer == NULL || current_renderer->BlitRotate == NULL)
521
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->BlitRotate == NULL)
522
522
return -2;
523
523
524
524
return current_renderer->BlitRotate(current_renderer, src, srcrect, dest, x, y, angle);
···
526
526
527
527
int GPU_BlitScale(GPU_Image* src, GPU_Rect* srcrect, GPU_Target* dest, float x, float y, float scaleX, float scaleY)
528
528
{
529
-
if(current_renderer == NULL || current_renderer->BlitScale == NULL)
529
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->BlitScale == NULL)
530
530
return -2;
531
531
532
532
return current_renderer->BlitScale(current_renderer, src, srcrect, dest, x, y, scaleX, scaleY);
···
534
534
535
535
int GPU_BlitTransform(GPU_Image* src, GPU_Rect* srcrect, GPU_Target* dest, float x, float y, float angle, float scaleX, float scaleY)
536
536
{
537
-
if(current_renderer == NULL || current_renderer->BlitTransform == NULL)
537
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->BlitTransform == NULL)
538
538
return -2;
539
539
540
540
return current_renderer->BlitTransform(current_renderer, src, srcrect, dest, x, y, angle, scaleX, scaleY);
···
542
542
543
543
int GPU_BlitTransformX(GPU_Image* src, GPU_Rect* srcrect, GPU_Target* dest, float x, float y, float pivot_x, float pivot_y, float angle, float scaleX, float scaleY)
544
544
{
545
-
if(current_renderer == NULL || current_renderer->BlitTransformX == NULL)
545
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->BlitTransformX == NULL)
546
546
return -2;
547
547
548
548
return current_renderer->BlitTransformX(current_renderer, src, srcrect, dest, x, y, pivot_x, pivot_y, angle, scaleX, scaleY);
···
550
550
551
551
int GPU_BlitTransformMatrix(GPU_Image* src, GPU_Rect* srcrect, GPU_Target* dest, float x, float y, float* matrix3x3)
552
552
{
553
-
if(current_renderer == NULL || current_renderer->BlitTransformMatrix == NULL || matrix3x3 == NULL)
553
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->BlitTransformMatrix == NULL || matrix3x3 == NULL)
554
554
return -2;
555
555
556
556
return current_renderer->BlitTransformMatrix(current_renderer, src, srcrect, dest, x, y, matrix3x3);
···
558
558
559
559
int GPU_BlitBatch(GPU_Image* src, GPU_Target* dest, unsigned int numSprites, float* values, GPU_BlitFlagEnum flags)
560
560
{
561
-
if(current_renderer == NULL || current_renderer->BlitBatch == NULL)
561
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->BlitBatch == NULL)
562
562
return -2;
563
563
if(src == NULL || dest == NULL)
564
564
return -1;
···
844
844
845
845
int GPU_BlitBatchSeparate(GPU_Image* src, GPU_Target* dest, unsigned int numSprites, float* positions, float* src_rects, float* colors, GPU_BlitFlagEnum flags)
846
846
{
847
-
if(current_renderer == NULL || current_renderer->BlitBatch == NULL)
847
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->BlitBatch == NULL)
848
848
return -2;
849
849
if(src == NULL || dest == NULL)
850
850
return -1;
···
1099
1099
1100
1100
int GPU_BlitBatchAttributes(GPU_Image* src, GPU_Target* dest, unsigned int numSprites, unsigned int numAttributes, GPU_Attribute* attributes)
1101
1101
{
1102
-
if(current_renderer == NULL || current_renderer->BlitBatchAttributes == NULL || numSprites == 0 || numAttributes == 0 || attributes == NULL)
1102
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->BlitBatchAttributes == NULL || numSprites == 0 || numAttributes == 0 || attributes == NULL)
1103
1103
return 0;
1104
1104
1105
1105
return current_renderer->BlitBatchAttributes(current_renderer, src, dest, numSprites, numAttributes, attributes);
···
1107
1107
1108
1108
void GPU_GenerateMipmaps(GPU_Image* image)
1109
1109
{
1110
-
if(current_renderer == NULL || current_renderer->GenerateMipmaps == NULL)
1110
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->GenerateMipmaps == NULL)
1111
1111
return;
1112
1112
1113
1113
current_renderer->GenerateMipmaps(current_renderer, image);
···
1118
1118
1119
1119
GPU_Rect GPU_SetClipRect(GPU_Target* target, GPU_Rect rect)
1120
1120
{
1121
-
if(target == NULL || current_renderer == NULL || current_renderer->SetClip == NULL)
1121
+
if(target == NULL || current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->SetClip == NULL)
1122
1122
{
1123
1123
GPU_Rect r = {0,0,0,0};
1124
1124
return r;
···
1129
1129
1130
1130
GPU_Rect GPU_SetClip(GPU_Target* target, Sint16 x, Sint16 y, Uint16 w, Uint16 h)
1131
1131
{
1132
-
if(target == NULL || current_renderer == NULL || current_renderer->SetClip == NULL)
1132
+
if(target == NULL || current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->SetClip == NULL)
1133
1133
{
1134
1134
GPU_Rect r = {0,0,0,0};
1135
1135
return r;
···
1140
1140
1141
1141
void GPU_ClearClip(GPU_Target* target)
1142
1142
{
1143
-
if(target == NULL || current_renderer == NULL || current_renderer->ClearClip == NULL)
1143
+
if(target == NULL || current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->ClearClip == NULL)
1144
1144
return;
1145
1145
1146
1146
current_renderer->ClearClip(current_renderer, target);
···
1277
1277
1278
1278
SDL_Color GPU_GetPixel(GPU_Target* target, Sint16 x, Sint16 y)
1279
1279
{
1280
-
if(current_renderer == NULL || current_renderer->GetPixel == NULL)
1280
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->GetPixel == NULL)
1281
1281
{
1282
1282
SDL_Color c = {0,0,0,0};
1283
1283
return c;
···
1294
1294
1295
1295
void GPU_Clear(GPU_Target* target)
1296
1296
{
1297
-
if(current_renderer == NULL || current_renderer->Clear == NULL)
1297
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->Clear == NULL)
1298
1298
return;
1299
1299
1300
1300
current_renderer->Clear(current_renderer, target);
···
1302
1302
1303
1303
void GPU_ClearRGBA(GPU_Target* target, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
1304
1304
{
1305
-
if(current_renderer == NULL || current_renderer->ClearRGBA == NULL)
1305
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->ClearRGBA == NULL)
1306
1306
return;
1307
1307
1308
1308
current_renderer->ClearRGBA(current_renderer, target, r, g, b, a);
···
1310
1310
1311
1311
void GPU_FlushBlitBuffer(void)
1312
1312
{
1313
-
if(current_renderer == NULL || current_renderer->FlushBlitBuffer == NULL)
1313
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->FlushBlitBuffer == NULL)
1314
1314
return;
1315
1315
1316
1316
current_renderer->FlushBlitBuffer(current_renderer);
···
1318
1318
1319
1319
void GPU_Flip(GPU_Target* target)
1320
1320
{
1321
-
if(current_renderer == NULL || current_renderer->Flip == NULL)
1321
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->Flip == NULL)
1322
1322
return;
1323
1323
1324
1324
current_renderer->Flip(current_renderer, target);
···
1333
1333
1334
1334
Uint32 GPU_CompileShader_RW(int shader_type, SDL_RWops* shader_source)
1335
1335
{
1336
-
if(current_renderer == NULL || current_renderer->CompileShader_RW == NULL)
1336
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->CompileShader_RW == NULL)
1337
1337
return 0;
1338
1338
1339
1339
return current_renderer->CompileShader_RW(current_renderer, shader_type, shader_source);
···
1349
1349
1350
1350
Uint32 GPU_CompileShader(int shader_type, const char* shader_source)
1351
1351
{
1352
-
if(current_renderer == NULL || current_renderer->CompileShader == NULL)
1352
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->CompileShader == NULL)
1353
1353
return 0;
1354
1354
1355
1355
return current_renderer->CompileShader(current_renderer, shader_type, shader_source);
···
1357
1357
1358
1358
Uint32 GPU_LinkShaderProgram(Uint32 program_object)
1359
1359
{
1360
-
if(current_renderer == NULL || current_renderer->LinkShaderProgram == NULL)
1360
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->LinkShaderProgram == NULL)
1361
1361
return 0;
1362
1362
1363
1363
return current_renderer->LinkShaderProgram(current_renderer, program_object);
···
1365
1365
1366
1366
Uint32 GPU_LinkShaders(Uint32 shader_object1, Uint32 shader_object2)
1367
1367
{
1368
-
if(current_renderer == NULL || current_renderer->LinkShaders == NULL)
1368
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->LinkShaders == NULL)
1369
1369
return 0;
1370
1370
1371
1371
return current_renderer->LinkShaders(current_renderer, shader_object1, shader_object2);
···
1373
1373
1374
1374
void GPU_FreeShader(Uint32 shader_object)
1375
1375
{
1376
-
if(current_renderer == NULL || current_renderer->FreeShader == NULL)
1376
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->FreeShader == NULL)
1377
1377
return;
1378
1378
1379
1379
current_renderer->FreeShader(current_renderer, shader_object);
···
1381
1381
1382
1382
void GPU_FreeShaderProgram(Uint32 program_object)
1383
1383
{
1384
-
if(current_renderer == NULL || current_renderer->FreeShaderProgram == NULL)
1384
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->FreeShaderProgram == NULL)
1385
1385
return;
1386
1386
1387
1387
current_renderer->FreeShaderProgram(current_renderer, program_object);
···
1389
1389
1390
1390
void GPU_AttachShader(Uint32 program_object, Uint32 shader_object)
1391
1391
{
1392
-
if(current_renderer == NULL || current_renderer->AttachShader == NULL)
1392
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->AttachShader == NULL)
1393
1393
return;
1394
1394
1395
1395
current_renderer->AttachShader(current_renderer, program_object, shader_object);
···
1397
1397
1398
1398
void GPU_DetachShader(Uint32 program_object, Uint32 shader_object)
1399
1399
{
1400
-
if(current_renderer == NULL || current_renderer->DetachShader == NULL)
1400
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->DetachShader == NULL)
1401
1401
return;
1402
1402
1403
1403
current_renderer->DetachShader(current_renderer, program_object, shader_object);
···
1405
1405
1406
1406
Uint8 GPU_IsDefaultShaderProgram(Uint32 program_object)
1407
1407
{
1408
-
if(current_renderer == NULL || current_renderer->IsDefaultShaderProgram == NULL)
1408
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->IsDefaultShaderProgram == NULL)
1409
1409
return 0;
1410
1410
1411
1411
return current_renderer->IsDefaultShaderProgram(current_renderer, program_object);
···
1413
1413
1414
1414
void GPU_ActivateShaderProgram(Uint32 program_object, GPU_ShaderBlock* block)
1415
1415
{
1416
-
if(current_renderer == NULL || current_renderer->ActivateShaderProgram == NULL)
1416
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->ActivateShaderProgram == NULL)
1417
1417
return;
1418
1418
1419
1419
current_renderer->ActivateShaderProgram(current_renderer, program_object, block);
···
1421
1421
1422
1422
void GPU_DeactivateShaderProgram(void)
1423
1423
{
1424
-
if(current_renderer == NULL || current_renderer->DeactivateShaderProgram == NULL)
1424
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->DeactivateShaderProgram == NULL)
1425
1425
return;
1426
1426
1427
1427
current_renderer->DeactivateShaderProgram(current_renderer);
···
1429
1429
1430
1430
const char* GPU_GetShaderMessage(void)
1431
1431
{
1432
-
if(current_renderer == NULL || current_renderer->GetShaderMessage == NULL)
1432
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->GetShaderMessage == NULL)
1433
1433
return NULL;
1434
1434
1435
1435
return current_renderer->GetShaderMessage(current_renderer);
···
1437
1437
1438
1438
int GPU_GetAttributeLocation(Uint32 program_object, const char* attrib_name)
1439
1439
{
1440
-
if(current_renderer == NULL || current_renderer->GetAttributeLocation == NULL)
1440
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->GetAttributeLocation == NULL)
1441
1441
return 0;
1442
1442
1443
1443
return current_renderer->GetAttributeLocation(current_renderer, program_object, attrib_name);
···
1457
1457
1458
1458
int GPU_GetUniformLocation(Uint32 program_object, const char* uniform_name)
1459
1459
{
1460
-
if(current_renderer == NULL || current_renderer->GetUniformLocation == NULL)
1460
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->GetUniformLocation == NULL)
1461
1461
return 0;
1462
1462
1463
1463
return current_renderer->GetUniformLocation(current_renderer, program_object, uniform_name);
···
1465
1465
1466
1466
GPU_ShaderBlock GPU_LoadShaderBlock(Uint32 program_object, const char* position_name, const char* texcoord_name, const char* color_name, const char* modelViewMatrix_name)
1467
1467
{
1468
-
if(current_renderer == NULL || current_renderer->LoadShaderBlock == NULL)
1468
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->LoadShaderBlock == NULL)
1469
1469
{
1470
1470
GPU_ShaderBlock b;
1471
1471
b.position_loc = -1;
···
1480
1480
1481
1481
void GPU_SetShaderBlock(GPU_ShaderBlock block)
1482
1482
{
1483
-
if(current_renderer == NULL || current_renderer->SetShaderBlock == NULL)
1483
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->SetShaderBlock == NULL)
1484
1484
return;
1485
1485
1486
1486
current_renderer->SetShaderBlock(current_renderer, block);
···
1488
1488
1489
1489
void GPU_GetUniformiv(Uint32 program_object, int location, int* values)
1490
1490
{
1491
-
if(current_renderer == NULL || current_renderer->GetUniformiv == NULL)
1491
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->GetUniformiv == NULL)
1492
1492
return;
1493
1493
1494
1494
current_renderer->GetUniformiv(current_renderer, program_object, location, values);
···
1496
1496
1497
1497
void GPU_SetUniformi(int location, int value)
1498
1498
{
1499
-
if(current_renderer == NULL || current_renderer->SetUniformi == NULL)
1499
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->SetUniformi == NULL)
1500
1500
return;
1501
1501
1502
1502
current_renderer->SetUniformi(current_renderer, location, value);
···
1504
1504
1505
1505
void GPU_SetUniformiv(int location, int num_elements_per_value, int num_values, int* values)
1506
1506
{
1507
-
if(current_renderer == NULL || current_renderer->SetUniformiv == NULL)
1507
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->SetUniformiv == NULL)
1508
1508
return;
1509
1509
1510
1510
current_renderer->SetUniformiv(current_renderer, location, num_elements_per_value, num_values, values);
···
1513
1513
1514
1514
void GPU_GetUniformuiv(Uint32 program_object, int location, unsigned int* values)
1515
1515
{
1516
-
if(current_renderer == NULL || current_renderer->GetUniformuiv == NULL)
1516
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->GetUniformuiv == NULL)
1517
1517
return;
1518
1518
1519
1519
current_renderer->GetUniformuiv(current_renderer, program_object, location, values);
···
1521
1521
1522
1522
void GPU_SetUniformui(int location, unsigned int value)
1523
1523
{
1524
-
if(current_renderer == NULL || current_renderer->SetUniformui == NULL)
1524
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->SetUniformui == NULL)
1525
1525
return;
1526
1526
1527
1527
current_renderer->SetUniformui(current_renderer, location, value);
···
1529
1529
1530
1530
void GPU_SetUniformuiv(int location, int num_elements_per_value, int num_values, unsigned int* values)
1531
1531
{
1532
-
if(current_renderer == NULL || current_renderer->SetUniformuiv == NULL)
1532
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->SetUniformuiv == NULL)
1533
1533
return;
1534
1534
1535
1535
current_renderer->SetUniformuiv(current_renderer, location, num_elements_per_value, num_values, values);
···
1538
1538
1539
1539
void GPU_GetUniformfv(Uint32 program_object, int location, float* values)
1540
1540
{
1541
-
if(current_renderer == NULL || current_renderer->GetUniformfv == NULL)
1541
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->GetUniformfv == NULL)
1542
1542
return;
1543
1543
1544
1544
current_renderer->GetUniformfv(current_renderer, program_object, location, values);
···
1546
1546
1547
1547
void GPU_SetUniformf(int location, float value)
1548
1548
{
1549
-
if(current_renderer == NULL || current_renderer->SetUniformf == NULL)
1549
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->SetUniformf == NULL)
1550
1550
return;
1551
1551
1552
1552
current_renderer->SetUniformf(current_renderer, location, value);
···
1554
1554
1555
1555
void GPU_SetUniformfv(int location, int num_elements_per_value, int num_values, float* values)
1556
1556
{
1557
-
if(current_renderer == NULL || current_renderer->SetUniformfv == NULL)
1557
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->SetUniformfv == NULL)
1558
1558
return;
1559
1559
1560
1560
current_renderer->SetUniformfv(current_renderer, location, num_elements_per_value, num_values, values);
···
1563
1563
// Same as GPU_GetUniformfv()
1564
1564
void GPU_GetUniformMatrixfv(Uint32 program_object, int location, float* values)
1565
1565
{
1566
-
if(current_renderer == NULL || current_renderer->GetUniformfv == NULL)
1566
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->GetUniformfv == NULL)
1567
1567
return;
1568
1568
1569
1569
current_renderer->GetUniformfv(current_renderer, program_object, location, values);
···
1571
1571
1572
1572
void GPU_SetUniformMatrixfv(int location, int num_matrices, int num_rows, int num_columns, Uint8 transpose, float* values)
1573
1573
{
1574
-
if(current_renderer == NULL || current_renderer->SetUniformMatrixfv == NULL)
1574
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL || current_renderer->SetUniformMatrixfv == NULL)
1575
1575
return;
1576
1576
1577
1577
current_renderer->SetUniformMatrixfv(current_renderer, location, num_matrices, num_rows, num_columns, transpose, values);