this repo has no description
Changed a bunch of enums so their styles match and the names indicate grouping. Image filters got GPU_FILTER_*, primitive types got GPU_TYPE_*, pixel formats got GPU_FORMAT_*, wrap modes changed a bit more and have GPU_WRAP_*, shader languages got GPU_LANGUAGE_*.
+85
-85
+1
-1
SDL_gpu/GLES_1/SDL_gpu_GLES_1.c
+1
-1
SDL_gpu/GLES_1/SDL_gpu_GLES_1.c
+1
-1
SDL_gpu/GLES_2/SDL_gpu_GLES_2.c
+1
-1
SDL_gpu/GLES_2/SDL_gpu_GLES_2.c
+25
-25
SDL_gpu/GL_common/SDL_gpu_GL_common.inl
+25
-25
SDL_gpu/GL_common/SDL_gpu_GL_common.inl
···
1559
1559
result->color = white;
1560
1560
result->use_blending = ((format == GPU_FORMAT_LUMINANCE_ALPHA || format == GPU_FORMAT_RGBA)? 1 : 0);
1561
1561
result->blend_mode = GPU_BLEND_NORMAL;
1562
-
result->filter_mode = GPU_LINEAR;
1563
-
result->wrap_mode_x = GPU_CLAMP_TO_EDGE;
1564
-
result->wrap_mode_y = GPU_CLAMP_TO_EDGE;
1562
+
result->filter_mode = GPU_FILTER_LINEAR;
1563
+
result->wrap_mode_x = GPU_WRAP_NONE;
1564
+
result->wrap_mode_y = GPU_WRAP_NONE;
1565
1565
1566
1566
result->data = data;
1567
1567
result->is_alias = 0;
···
2338
2338
GPU_FilterEnum filter_mode = image->filter_mode;
2339
2339
GPU_SetColor(image, NULL);
2340
2340
GPU_SetBlending(image, 0);
2341
-
GPU_SetImageFilter(image, GPU_NEAREST);
2341
+
GPU_SetImageFilter(image, GPU_FILTER_NEAREST);
2342
2342
2343
2343
renderer->Blit(renderer, image, NULL, target, image->w/2, image->h/2);
2344
2344
···
2806
2806
Uint16 tex_w = image->texture_w;
2807
2807
Uint16 tex_h = image->texture_h;
2808
2808
2809
-
if(image->filter_mode == GPU_NEAREST)
2809
+
if(image->filter_mode == GPU_FILTER_NEAREST)
2810
2810
{
2811
2811
// Avoid rounding errors in texture sampling by insisting on integral pixel positions
2812
2812
x = floorf(x+0.5f);
···
2983
2983
Uint16 tex_w = image->texture_w;
2984
2984
Uint16 tex_h = image->texture_h;
2985
2985
2986
-
if(image->filter_mode == GPU_NEAREST)
2986
+
if(image->filter_mode == GPU_FILTER_NEAREST)
2987
2987
{
2988
2988
// Avoid rounding errors in texture sampling by insisting on integral pixel positions
2989
2989
x = floorf(x+0.5f);
···
3188
3188
3189
3189
static inline int sizeof_GPU_type(GPU_TypeEnum type)
3190
3190
{
3191
-
if(type == GPU_DOUBLE) return sizeof(double);
3192
-
if(type == GPU_FLOAT) return sizeof(float);
3193
-
if(type == GPU_INT) return sizeof(int);
3194
-
if(type == GPU_UNSIGNED_INT) return sizeof(unsigned int);
3195
-
if(type == GPU_SHORT) return sizeof(short);
3196
-
if(type == GPU_UNSIGNED_SHORT) return sizeof(unsigned short);
3197
-
if(type == GPU_BYTE) return sizeof(char);
3198
-
if(type == GPU_UNSIGNED_BYTE) return sizeof(unsigned char);
3191
+
if(type == GPU_TYPE_DOUBLE) return sizeof(double);
3192
+
if(type == GPU_TYPE_FLOAT) return sizeof(float);
3193
+
if(type == GPU_TYPE_INT) return sizeof(int);
3194
+
if(type == GPU_TYPE_UNSIGNED_INT) return sizeof(unsigned int);
3195
+
if(type == GPU_TYPE_SHORT) return sizeof(short);
3196
+
if(type == GPU_TYPE_UNSIGNED_SHORT) return sizeof(unsigned short);
3197
+
if(type == GPU_TYPE_BYTE) return sizeof(char);
3198
+
if(type == GPU_TYPE_UNSIGNED_BYTE) return sizeof(unsigned char);
3199
3199
return 0;
3200
3200
}
3201
3201
···
3839
3839
3840
3840
switch(filter)
3841
3841
{
3842
-
case GPU_NEAREST:
3842
+
case GPU_FILTER_NEAREST:
3843
3843
minFilter = GL_NEAREST;
3844
3844
magFilter = GL_NEAREST;
3845
3845
break;
3846
-
case GPU_LINEAR:
3846
+
case GPU_FILTER_LINEAR:
3847
3847
if(image->has_mipmaps)
3848
3848
minFilter = GL_LINEAR_MIPMAP_NEAREST;
3849
3849
else
···
3851
3851
3852
3852
magFilter = GL_LINEAR;
3853
3853
break;
3854
-
case GPU_LINEAR_MIPMAP:
3854
+
case GPU_FILTER_LINEAR_MIPMAP:
3855
3855
if(image->has_mipmaps)
3856
3856
minFilter = GL_LINEAR_MIPMAP_LINEAR;
3857
3857
else
···
3890
3890
3891
3891
switch(wrap_mode_x)
3892
3892
{
3893
-
case GPU_CLAMP_TO_EDGE:
3893
+
case GPU_WRAP_NONE:
3894
3894
wrap_x = GL_CLAMP_TO_EDGE;
3895
3895
break;
3896
-
case GPU_REPEAT:
3896
+
case GPU_WRAP_REPEAT:
3897
3897
wrap_x = GL_REPEAT;
3898
3898
break;
3899
-
case GPU_REPEAT_MIRRORED:
3899
+
case GPU_WRAP_MIRRORED:
3900
3900
if(renderer->enabled_features & GPU_FEATURE_WRAP_REPEAT_MIRRORED)
3901
3901
wrap_x = GL_MIRRORED_REPEAT;
3902
3902
else
3903
3903
{
3904
-
GPU_PushErrorCode("GPU_SetWrapMode", GPU_ERROR_BACKEND_ERROR, "This renderer does not support GPU_REPEAT_MIRRORED.");
3904
+
GPU_PushErrorCode("GPU_SetWrapMode", GPU_ERROR_BACKEND_ERROR, "This renderer does not support GPU_WRAP_MIRRORED.");
3905
3905
return;
3906
3906
}
3907
3907
break;
···
3912
3912
3913
3913
switch(wrap_mode_y)
3914
3914
{
3915
-
case GPU_CLAMP_TO_EDGE:
3915
+
case GPU_WRAP_NONE:
3916
3916
wrap_y = GL_CLAMP_TO_EDGE;
3917
3917
break;
3918
-
case GPU_REPEAT:
3918
+
case GPU_WRAP_REPEAT:
3919
3919
wrap_y = GL_REPEAT;
3920
3920
break;
3921
-
case GPU_REPEAT_MIRRORED:
3921
+
case GPU_WRAP_MIRRORED:
3922
3922
if(renderer->enabled_features & GPU_FEATURE_WRAP_REPEAT_MIRRORED)
3923
3923
wrap_y = GL_MIRRORED_REPEAT;
3924
3924
else
3925
3925
{
3926
-
GPU_PushErrorCode("GPU_SetWrapMode", GPU_ERROR_BACKEND_ERROR, "This renderer does not support GPU_REPEAT_MIRRORED.");
3926
+
GPU_PushErrorCode("GPU_SetWrapMode", GPU_ERROR_BACKEND_ERROR, "This renderer does not support GPU_WRAP_MIRRORED.");
3927
3927
return;
3928
3928
}
3929
3929
break;
+1
-1
SDL_gpu/OpenGL_1/SDL_gpu_OpenGL_1.c
+1
-1
SDL_gpu/OpenGL_1/SDL_gpu_OpenGL_1.c
+1
-1
SDL_gpu/OpenGL_1_BASE/SDL_gpu_OpenGL_1_BASE.c
+1
-1
SDL_gpu/OpenGL_1_BASE/SDL_gpu_OpenGL_1_BASE.c
+1
-1
SDL_gpu/OpenGL_2/SDL_gpu_OpenGL_2.c
+1
-1
SDL_gpu/OpenGL_2/SDL_gpu_OpenGL_2.c
+1
-1
SDL_gpu/OpenGL_3/SDL_gpu_OpenGL_3.c
+1
-1
SDL_gpu/OpenGL_3/SDL_gpu_OpenGL_3.c
+21
-21
SDL_gpu/SDL_gpu.h
+21
-21
SDL_gpu/SDL_gpu.h
···
67
67
* \see GPU_SetImageFilter()
68
68
*/
69
69
typedef enum {
70
-
GPU_NEAREST = 0,
71
-
GPU_LINEAR = 1,
72
-
GPU_LINEAR_MIPMAP = 2
70
+
GPU_FILTER_NEAREST = 0,
71
+
GPU_FILTER_LINEAR = 1,
72
+
GPU_FILTER_LINEAR_MIPMAP = 2
73
73
} GPU_FilterEnum;
74
74
75
75
/*! Image wrapping options. These affect how images handle src_rect coordinates beyond their dimensions when blitted.
76
76
* \see GPU_SetWrapMode()
77
77
*/
78
78
typedef enum {
79
-
GPU_CLAMP_TO_EDGE = 0,
80
-
GPU_REPEAT = 1,
81
-
GPU_REPEAT_MIRRORED = 2
79
+
GPU_WRAP_NONE = 0,
80
+
GPU_WRAP_REPEAT = 1,
81
+
GPU_WRAP_MIRRORED = 2
82
82
} GPU_WrapEnum;
83
83
84
84
/*! Blending options
···
323
323
/*! Type enumeration for GPU_AttributeFormat specifications. */
324
324
typedef Uint32 GPU_TypeEnum;
325
325
// Use OpenGL's values for simpler translation
326
-
static const GPU_TypeEnum GPU_BYTE = 0x1400;
327
-
static const GPU_TypeEnum GPU_UNSIGNED_BYTE = 0x1401;
328
-
static const GPU_TypeEnum GPU_SHORT = 0x1402;
329
-
static const GPU_TypeEnum GPU_UNSIGNED_SHORT = 0x1403;
330
-
static const GPU_TypeEnum GPU_INT = 0x1404;
331
-
static const GPU_TypeEnum GPU_UNSIGNED_INT = 0x1405;
332
-
static const GPU_TypeEnum GPU_FLOAT = 0x1406;
333
-
static const GPU_TypeEnum GPU_DOUBLE = 0x140A;
326
+
static const GPU_TypeEnum GPU_TYPE_BYTE = 0x1400;
327
+
static const GPU_TypeEnum GPU_TYPE_UNSIGNED_BYTE = 0x1401;
328
+
static const GPU_TypeEnum GPU_TYPE_SHORT = 0x1402;
329
+
static const GPU_TypeEnum GPU_TYPE_UNSIGNED_SHORT = 0x1403;
330
+
static const GPU_TypeEnum GPU_TYPE_INT = 0x1404;
331
+
static const GPU_TypeEnum GPU_TYPE_UNSIGNED_INT = 0x1405;
332
+
static const GPU_TypeEnum GPU_TYPE_FLOAT = 0x1406;
333
+
static const GPU_TypeEnum GPU_TYPE_DOUBLE = 0x140A;
334
334
335
335
336
336
···
351
351
352
352
/*! Type enumeration for the shader language used by the renderer. */
353
353
typedef enum {
354
-
GPU_NO_SHADERS = 0,
355
-
GPU_ARB_ASSEMBLY = 1,
356
-
GPU_GLSL = 2,
357
-
GPU_GLSLES = 3,
358
-
GPU_HLSL = 4,
359
-
GPU_CG = 5
354
+
GPU_LANGUAGE_NONE = 0,
355
+
GPU_LANGUAGE_ARB_ASSEMBLY = 1,
356
+
GPU_LANGUAGE_GLSL = 2,
357
+
GPU_LANGUAGE_GLSLES = 3,
358
+
GPU_LANGUAGE_HLSL = 4,
359
+
GPU_LANGUAGE_CG = 5
360
360
} GPU_ShaderLanguageEnum;
361
361
362
362
typedef struct GPU_AttributeFormat
363
363
{
364
364
Uint8 is_per_sprite; // Per-sprite values are expanded to 4 vertices
365
365
int num_elems_per_value;
366
-
GPU_TypeEnum type; // GPU_FLOAT, GPU_INT, GPU_UNSIGNED_INT, etc.
366
+
GPU_TypeEnum type; // GPU_TYPE_FLOAT, GPU_TYPE_INT, GPU_TYPE_UNSIGNED_INT, etc.
367
367
Uint8 normalize;
368
368
int stride_bytes; // Number of bytes between two vertex specifications
369
369
int offset_bytes; // Number of bytes to skip at the beginning of 'values'
+1
-1
demos/alias/main.c
+1
-1
demos/alias/main.c
+3
-3
demos/blit-batch/main.c
+3
-3
demos/blit-batch/main.c
···
303
303
304
304
GPU_Attribute attributes[3] = {
305
305
GPU_MakeAttribute(GPU_GetAttributeLocation(program_object, "gpu_Vertex"), sprite_values,
306
-
GPU_MakeAttributeFormat(2, GPU_FLOAT, 0, floats_per_vertex*sizeof(float), 0)),
306
+
GPU_MakeAttributeFormat(2, GPU_TYPE_FLOAT, 0, floats_per_vertex*sizeof(float), 0)),
307
307
GPU_MakeAttribute(GPU_GetAttributeLocation(program_object, "gpu_TexCoord"), sprite_values,
308
-
GPU_MakeAttributeFormat(2, GPU_FLOAT, 0, floats_per_vertex*sizeof(float), 2*sizeof(float))),
308
+
GPU_MakeAttributeFormat(2, GPU_TYPE_FLOAT, 0, floats_per_vertex*sizeof(float), 2*sizeof(float))),
309
309
GPU_MakeAttribute(GPU_GetAttributeLocation(program_object, "gpu_Color"), sprite_values,
310
-
GPU_MakeAttributeFormat(4, GPU_FLOAT, 0, floats_per_vertex*sizeof(float), 4*sizeof(float)))
310
+
GPU_MakeAttributeFormat(4, GPU_TYPE_FLOAT, 0, floats_per_vertex*sizeof(float), 4*sizeof(float)))
311
311
};
312
312
313
313
float* velx = (float*)malloc(sizeof(float)*maxSprites);
+6
-6
demos/intermediate/main.c
+6
-6
demos/intermediate/main.c
···
38
38
GPU_Image* images[max_images];
39
39
40
40
int using_images = 1;
41
-
GPU_FilterEnum filter_mode = GPU_NEAREST;
41
+
GPU_FilterEnum filter_mode = GPU_FILTER_NEAREST;
42
42
Uint8 show_original = 0;
43
43
44
44
Uint8 switched = 1;
···
103
103
show_original = !show_original;
104
104
else if(event.key.keysym.sym == SDLK_f)
105
105
{
106
-
if(filter_mode == GPU_NEAREST)
106
+
if(filter_mode == GPU_FILTER_NEAREST)
107
107
{
108
-
filter_mode = GPU_LINEAR;
109
-
GPU_LogError("GPU_LINEAR\n");
108
+
filter_mode = GPU_FILTER_LINEAR;
109
+
GPU_LogError("GPU_FILTER_LINEAR\n");
110
110
}
111
111
else
112
112
{
113
-
filter_mode = GPU_NEAREST;
114
-
GPU_LogError("GPU_NEAREST\n");
113
+
filter_mode = GPU_FILTER_NEAREST;
114
+
GPU_LogError("GPU_FILTER_NEAREST\n");
115
115
}
116
116
117
117
+2
-2
demos/mipmap/main.c
+2
-2
demos/mipmap/main.c
···
19
19
20
20
GPU_Image* image2 = GPU_CopyImage(image);
21
21
GPU_GenerateMipmaps(image2);
22
-
GPU_SetImageFilter(image2, GPU_LINEAR);
22
+
GPU_SetImageFilter(image2, GPU_FILTER_LINEAR);
23
23
24
24
GPU_Image* image3 = GPU_CopyImage(image);
25
25
GPU_GenerateMipmaps(image3);
26
-
GPU_SetImageFilter(image3, GPU_LINEAR_MIPMAP);
26
+
GPU_SetImageFilter(image3, GPU_FILTER_LINEAR_MIPMAP);
27
27
28
28
Uint32 startTime = SDL_GetTicks();
29
29
long frameCount = 0;
+5
-5
demos/pixel-perfect/main.c
+5
-5
demos/pixel-perfect/main.c
···
55
55
}
56
56
else if(event.key.keysym.sym == SDLK_f)
57
57
{
58
-
if(image->filter_mode == GPU_NEAREST)
58
+
if(image->filter_mode == GPU_FILTER_NEAREST)
59
59
{
60
-
GPU_SetImageFilter(image, GPU_LINEAR);
61
-
GPU_LogError("GPU_LINEAR\n");
60
+
GPU_SetImageFilter(image, GPU_FILTER_LINEAR);
61
+
GPU_LogError("GPU_FILTER_LINEAR\n");
62
62
}
63
63
else
64
64
{
65
-
GPU_SetImageFilter(image, GPU_NEAREST);
66
-
GPU_LogError("GPU_NEAREST\n");
65
+
GPU_SetImageFilter(image, GPU_FILTER_NEAREST);
66
+
GPU_LogError("GPU_FILTER_NEAREST\n");
67
67
}
68
68
}
69
69
else if(event.key.keysym.sym == SDLK_UP)
+1
-1
demos/polygon-blit/main.c
+1
-1
demos/polygon-blit/main.c
···
30
30
31
31
GPU_WrapEnum wrap_x = image->wrap_mode_x;
32
32
GPU_WrapEnum wrap_y = image->wrap_mode_y;
33
-
GPU_SetWrapMode(image, GPU_REPEAT, GPU_REPEAT);
33
+
GPU_SetWrapMode(image, GPU_WRAP_REPEAT, GPU_WRAP_REPEAT);
34
34
35
35
float* vertices = (float*)malloc(8*num_vertices*sizeof(float));
36
36
unsigned short* indices = (unsigned short*)malloc((3 + (num_vertices-3)*3)*sizeof(unsigned short));
+1
-1
demos/shader-attributes/main.c
+1
-1
demos/shader-attributes/main.c
···
135
135
float expanded_colors[4*maxSprites];
136
136
float src_rects[4*maxSprites];
137
137
138
-
color_attr.format = GPU_MakeAttributeFormat(4, GPU_FLOAT, 0, 4*sizeof(float), 0);
138
+
color_attr.format = GPU_MakeAttributeFormat(4, GPU_TYPE_FLOAT, 0, 4*sizeof(float), 0);
139
139
color_attr.format.is_per_sprite = 0;
140
140
color_attr.values = colors;
141
141
+3
-3
demos/triangle-batch/main.c
+3
-3
demos/triangle-batch/main.c
···
367
367
368
368
GPU_Attribute attributes[3] = {
369
369
GPU_MakeAttribute(GPU_GetAttributeLocation(program_object, "gpu_Vertex"), vertex_values,
370
-
GPU_MakeAttributeFormat(2, GPU_FLOAT, 0, floats_per_vertex*sizeof(float), 0)),
370
+
GPU_MakeAttributeFormat(2, GPU_TYPE_FLOAT, 0, floats_per_vertex*sizeof(float), 0)),
371
371
GPU_MakeAttribute(GPU_GetAttributeLocation(program_object, "gpu_TexCoord"), vertex_values,
372
-
GPU_MakeAttributeFormat(2, GPU_FLOAT, 0, floats_per_vertex*sizeof(float), 2*sizeof(float))),
372
+
GPU_MakeAttributeFormat(2, GPU_TYPE_FLOAT, 0, floats_per_vertex*sizeof(float), 2*sizeof(float))),
373
373
GPU_MakeAttribute(GPU_GetAttributeLocation(program_object, "gpu_Color"), vertex_values,
374
-
GPU_MakeAttributeFormat(4, GPU_FLOAT, 0, floats_per_vertex*sizeof(float), 4*sizeof(float)))
374
+
GPU_MakeAttributeFormat(4, GPU_TYPE_FLOAT, 0, floats_per_vertex*sizeof(float), 4*sizeof(float)))
375
375
};
376
376
377
377
float* velx = (float*)malloc(sizeof(float)*max_vertices/3);
+11
-11
demos/wrap/main.c
+11
-11
demos/wrap/main.c
···
52
52
53
53
float x = 0;
54
54
float y = 0;
55
-
FONT_Draw(font, screen, x + 10, y + 10, "CLAMP_TO_EDGE");
55
+
FONT_Draw(font, screen, x + 10, y + 10, "NONE");
56
56
x += 40;
57
57
y += 20;
58
-
GPU_SetWrapMode(image, GPU_CLAMP_TO_EDGE, GPU_CLAMP_TO_EDGE);
58
+
GPU_SetWrapMode(image, GPU_WRAP_NONE, GPU_WRAP_NONE);
59
59
GPU_Blit(image, &rect1, screen, x + rect1.w/2, y + rect1.h/2);
60
60
x += image->w*4;
61
61
GPU_Blit(image, &rect2, screen, x + rect2.w/2, y + rect2.h/2);
···
65
65
FONT_Draw(font, screen, x + 10, y + 10, "REPEAT");
66
66
x += 40;
67
67
y += 20;
68
-
GPU_SetWrapMode(image, GPU_REPEAT, GPU_REPEAT);
68
+
GPU_SetWrapMode(image, GPU_WRAP_REPEAT, GPU_WRAP_REPEAT);
69
69
GPU_Blit(image, &rect1, screen, x + rect1.w/2, y + rect1.h/2);
70
70
x += image->w*4;
71
71
GPU_Blit(image, &rect2, screen, x + rect2.w/2, y + rect2.h/2);
72
72
73
73
x = 0;
74
74
y += (rect1.h + 10);
75
-
FONT_Draw(font, screen, x + 10, y + 10, "REPEAT_MIRRORED");
75
+
FONT_Draw(font, screen, x + 10, y + 10, "MIRRORED");
76
76
x += 40;
77
77
y += 20;
78
-
GPU_SetWrapMode(image, GPU_REPEAT_MIRRORED, GPU_REPEAT_MIRRORED);
78
+
GPU_SetWrapMode(image, GPU_WRAP_MIRRORED, GPU_WRAP_MIRRORED);
79
79
GPU_Blit(image, &rect1, screen, x + rect1.w/2, y + rect1.h/2);
80
80
x += image->w*4;
81
81
GPU_Blit(image, &rect2, screen, x + rect2.w/2, y + rect2.h/2);
82
82
83
83
x = 500;
84
84
y = 0;
85
-
FONT_Draw(font, screen, x + 10, y + 10, "REPEAT/REPEAT_MIRRORED");
85
+
FONT_Draw(font, screen, x + 10, y + 10, "REPEAT/MIRRORED");
86
86
x += 40;
87
87
y += 20;
88
-
GPU_SetWrapMode(image, GPU_REPEAT, GPU_REPEAT_MIRRORED);
88
+
GPU_SetWrapMode(image, GPU_WRAP_REPEAT, GPU_WRAP_MIRRORED);
89
89
GPU_Blit(image, &rect1, screen, x + rect1.w/2, y + rect1.h/2);
90
90
x += image->w*4;
91
91
GPU_Blit(image, &rect2, screen, x + rect2.w/2, y + rect2.h/2);
92
92
93
93
x = 500;
94
94
y += (rect1.h + 10);
95
-
FONT_Draw(font, screen, x + 10, y + 10, "CLAMP_TO_EDGE/REPEAT");
95
+
FONT_Draw(font, screen, x + 10, y + 10, "NONE/REPEAT");
96
96
x += 40;
97
97
y += 20;
98
-
GPU_SetWrapMode(image, GPU_CLAMP_TO_EDGE, GPU_REPEAT);
98
+
GPU_SetWrapMode(image, GPU_WRAP_NONE, GPU_WRAP_REPEAT);
99
99
GPU_Blit(image, &rect1, screen, x + rect1.w/2, y + rect1.h/2);
100
100
x += image->w*4;
101
101
GPU_Blit(image, &rect2, screen, x + rect2.w/2, y + rect2.h/2);
102
102
103
103
x = 500;
104
104
y += (rect1.h + 10);
105
-
FONT_Draw(font, screen, x + 10, y + 10, "CLAMP_TO_EDGE/REPEAT_MIRRORED");
105
+
FONT_Draw(font, screen, x + 10, y + 10, "NONE/MIRRORED");
106
106
x += 40;
107
107
y += 20;
108
-
GPU_SetWrapMode(image, GPU_CLAMP_TO_EDGE, GPU_REPEAT_MIRRORED);
108
+
GPU_SetWrapMode(image, GPU_WRAP_NONE, GPU_WRAP_MIRRORED);
109
109
GPU_Blit(image, &rect1, screen, x + rect1.w/2, y + rect1.h/2);
110
110
x += image->w*4;
111
111
GPU_Blit(image, &rect2, screen, x + rect2.w/2, y + rect2.h/2);