this repo has no description
Added renderer-demo to test out new custom renderer API. Most of the other changes are to enable that.
Added SDL_GPU_USE_SDL1 and GPU_RENDERER_CUSTOM_0. Changed renderer enum values so they can no longer be safely OR'd together. Added GPU_ReserveNextRendererEnum() and GPU_RegisterRenderer(). Removed GPU_AddRenderer() and GPU_RemoveRenderer(). Moved LinkShaders() logic into GPU_LinkShaders(). Made copy functions use base_w and base_h. Added GPU_CreateShaderProgram(). Moved IsDefaultShaderProgram() logic into GPU_ActivateShaderProgram().
+1560
-141
+1
SDL_gpu/CMakeLists.txt
+1
SDL_gpu/CMakeLists.txt
+45
-51
SDL_gpu/GL_common/SDL_gpu_GL_common.inl
+45
-51
SDL_gpu/GL_common/SDL_gpu_GL_common.inl
···
94
94
#endif
95
95
96
96
97
-
// Internal API for managing window mappings
98
-
void GPU_AddWindowMapping(GPU_Target* target);
99
-
void GPU_RemoveWindowMapping(Uint32 windowID);
100
-
void GPU_RemoveWindowMappingByTarget(GPU_Target* target);
101
97
102
98
103
99
static SDL_PixelFormat* AllocFormat(GLenum glFormat);
···
1222
1218
return NULL;
1223
1219
}
1224
1220
1225
-
p = renderer->impl->LinkShaders(renderer, v, f);
1221
+
p = renderer->impl->CreateShaderProgram(renderer);
1222
+
renderer->impl->AttachShader(renderer, p, v);
1223
+
renderer->impl->AttachShader(renderer, p, f);
1224
+
renderer->impl->LinkShaderProgram(renderer, p);
1226
1225
1227
1226
if(!p)
1228
1227
{
···
1256
1255
return NULL;
1257
1256
}
1258
1257
1259
-
p = renderer->impl->LinkShaders(renderer, v, f);
1258
+
p = renderer->impl->CreateShaderProgram(renderer);
1259
+
renderer->impl->AttachShader(renderer, p, v);
1260
+
renderer->impl->AttachShader(renderer, p, f);
1261
+
renderer->impl->LinkShaderProgram(renderer, p);
1260
1262
1261
1263
if(!p)
1262
1264
{
···
1387
1389
{
1388
1390
target->context->window_w = screen->w;
1389
1391
target->context->window_h = screen->h;
1392
+
target->base_w = target->context->window_w;
1393
+
target->base_h = target->context->window_h;
1390
1394
}
1391
1395
#endif
1392
1396
}
···
2137
2141
bytes_per_pixel = 4;
2138
2142
if(target->image != NULL)
2139
2143
bytes_per_pixel = target->image->bytes_per_pixel;
2140
-
data = (unsigned char*)malloc(target->w * target->h * bytes_per_pixel);
2144
+
data = (unsigned char*)malloc(target->base_w * target->base_h * bytes_per_pixel);
2141
2145
2142
2146
if(!readTargetPixels(renderer, target, ((GPU_TARGET_DATA*)target->data)->format, data))
2143
2147
{
···
2146
2150
}
2147
2151
2148
2152
// Flip the data vertically (OpenGL framebuffer is read upside down)
2149
-
pitch = target->w * bytes_per_pixel;
2153
+
pitch = target->base_w * bytes_per_pixel;
2150
2154
copy = (unsigned char*)malloc(pitch);
2151
2155
2152
-
for(y = 0; y < target->h/2; y++)
2156
+
for(y = 0; y < target->base_h/2; y++)
2153
2157
{
2154
-
unsigned char* top = &data[target->w * y * bytes_per_pixel];
2155
-
unsigned char* bottom = &data[target->w * (target->h - y - 1) * bytes_per_pixel];
2158
+
unsigned char* top = &data[target->base_w * y * bytes_per_pixel];
2159
+
unsigned char* bottom = &data[target->base_w * (target->base_h - y - 1) * bytes_per_pixel];
2156
2160
memcpy(copy, top, pitch);
2157
2161
memcpy(top, bottom, pitch);
2158
2162
memcpy(bottom, copy, pitch);
···
2169
2173
if(image->target != NULL && isCurrentTarget(renderer, image->target))
2170
2174
renderer->impl->FlushBlitBuffer(renderer);
2171
2175
2172
-
data = (unsigned char*)malloc(image->w * image->h * image->bytes_per_pixel);
2176
+
data = (unsigned char*)malloc(image->base_w * image->base_h * image->bytes_per_pixel);
2173
2177
2174
2178
// FIXME: Sometimes the texture is stored and read in RGBA even when I specify RGB. getRawImageData() might need to return the stored format or Bpp.
2175
2179
if(!readImagePixels(renderer, image, ((GPU_IMAGE_DATA*)image->data)->format, data))
···
2197
2201
unsigned char* data;
2198
2202
2199
2203
if(image == NULL || filename == NULL ||
2200
-
image->w < 1 || image->h < 1 || image->bytes_per_pixel < 1 || image->bytes_per_pixel > 4)
2204
+
image->base_w < 1 || image->base_h < 1 || image->bytes_per_pixel < 1 || image->bytes_per_pixel > 4)
2201
2205
{
2202
2206
return 0;
2203
2207
}
···
2213
2217
}
2214
2218
2215
2219
if(SDL_strcasecmp(extension, "png") == 0)
2216
-
result = stbi_write_png(filename, image->w, image->h, image->bytes_per_pixel, (const unsigned char *const)data, 0);
2220
+
result = stbi_write_png(filename, image->base_w, image->base_h, image->bytes_per_pixel, (const unsigned char *const)data, 0);
2217
2221
else if(SDL_strcasecmp(extension, "bmp") == 0)
2218
-
result = stbi_write_bmp(filename, image->w, image->h, image->bytes_per_pixel, (void*)data);
2222
+
result = stbi_write_bmp(filename, image->base_w, image->base_h, image->bytes_per_pixel, (void*)data);
2219
2223
else if(SDL_strcasecmp(extension, "tga") == 0)
2220
-
result = stbi_write_tga(filename, image->w, image->h, image->bytes_per_pixel, (void*)data);
2224
+
result = stbi_write_tga(filename, image->base_w, image->base_h, image->bytes_per_pixel, (void*)data);
2221
2225
else
2222
2226
{
2223
2227
GPU_PushErrorCode("GPU_SaveImage", GPU_ERROR_DATA_ERROR, "Unsupported output file format (%s)", extension);
···
2239
2243
GPU_PushErrorCode("GPU_CopySurfaceFromTarget", GPU_ERROR_NULL_ARGUMENT, "target");
2240
2244
return NULL;
2241
2245
}
2242
-
if(target->w < 1 || target->h < 1)
2246
+
if(target->base_w < 1 || target->base_h < 1)
2243
2247
{
2244
-
GPU_PushErrorCode("GPU_CopySurfaceFromTarget", GPU_ERROR_DATA_ERROR, "Invalid target dimensions (%dx%d)", target->w, target->h);
2248
+
GPU_PushErrorCode("GPU_CopySurfaceFromTarget", GPU_ERROR_DATA_ERROR, "Invalid target dimensions (%dx%d)", target->base_w, target->base_h);
2245
2249
return NULL;
2246
2250
}
2247
2251
···
2255
2259
2256
2260
format = AllocFormat(((GPU_TARGET_DATA*)target->data)->format);
2257
2261
2258
-
result = SDL_CreateRGBSurfaceFrom(data, target->w, target->h, format->BitsPerPixel, target->w*format->BytesPerPixel, format->Rmask, format->Gmask, format->Bmask, format->Amask);
2262
+
result = SDL_CreateRGBSurfaceFrom(data, target->base_w, target->base_h, format->BitsPerPixel, target->base_w*format->BytesPerPixel, format->Rmask, format->Gmask, format->Bmask, format->Amask);
2259
2263
if(result != NULL)
2260
2264
result->flags &= ~SDL_PREALLOC; // Make SDL take ownership of the data memory
2261
2265
···
2274
2278
GPU_PushErrorCode("GPU_CopySurfaceFromImage", GPU_ERROR_NULL_ARGUMENT, "image");
2275
2279
return NULL;
2276
2280
}
2277
-
if(image->w < 1 || image->h < 1)
2281
+
if(image->base_w < 1 || image->base_h < 1)
2278
2282
{
2279
-
GPU_PushErrorCode("GPU_CopySurfaceFromImage", GPU_ERROR_DATA_ERROR, "Invalid image dimensions (%dx%d)", image->w, image->h);
2283
+
GPU_PushErrorCode("GPU_CopySurfaceFromImage", GPU_ERROR_DATA_ERROR, "Invalid image dimensions (%dx%d)", image->base_w, image->base_h);
2280
2284
return NULL;
2281
2285
}
2282
2286
···
2290
2294
2291
2295
format = AllocFormat(((GPU_IMAGE_DATA*)image->data)->format);
2292
2296
2293
-
result = SDL_CreateRGBSurfaceFrom(data, image->w, image->h, format->BitsPerPixel, image->w*format->BytesPerPixel, format->Rmask, format->Gmask, format->Bmask, format->Amask);
2297
+
result = SDL_CreateRGBSurfaceFrom(data, image->base_w, image->base_h, format->BitsPerPixel, image->base_w*format->BytesPerPixel, format->Rmask, format->Gmask, format->Bmask, format->Amask);
2294
2298
if(result != NULL)
2295
2299
result->flags &= ~SDL_PREALLOC; // Make SDL take ownership of the data memory
2296
2300
···
5299
5303
return size;
5300
5304
}
5301
5305
5302
-
static Uint32 LinkShaderProgram(GPU_Renderer* renderer, Uint32 program_object)
5306
+
static Uint32 CreateShaderProgram(GPU_Renderer* renderer)
5307
+
{
5308
+
#ifndef SDL_GPU_DISABLE_SHADERS
5309
+
GLuint p;
5310
+
5311
+
if(!IsFeatureEnabled(renderer, GPU_FEATURE_BASIC_SHADERS))
5312
+
return 0;
5313
+
5314
+
p = glCreateProgram();
5315
+
5316
+
return p;
5317
+
#else
5318
+
return 0;
5319
+
#endif
5320
+
}
5321
+
5322
+
static Uint8 LinkShaderProgram(GPU_Renderer* renderer, Uint32 program_object)
5303
5323
{
5304
5324
#ifndef SDL_GPU_DISABLE_SHADERS
5305
5325
int linked;
···
5319
5339
return 0;
5320
5340
}
5321
5341
5322
-
return program_object;
5342
+
return 1;
5323
5343
5324
5344
#else
5325
5345
···
5328
5348
#endif
5329
5349
}
5330
5350
5331
-
static Uint32 LinkShaders(GPU_Renderer* renderer, Uint32 shader_object1, Uint32 shader_object2)
5332
-
{
5333
-
#ifndef SDL_GPU_DISABLE_SHADERS
5334
-
GLuint p;
5335
-
5336
-
if(!IsFeatureEnabled(renderer, GPU_FEATURE_BASIC_SHADERS))
5337
-
return 0;
5338
-
5339
-
p = glCreateProgram();
5340
-
5341
-
glAttachShader(p, shader_object1);
5342
-
glAttachShader(p, shader_object2);
5343
-
5344
-
return renderer->impl->LinkShaderProgram(renderer, p);
5345
-
#else
5346
-
return 0;
5347
-
#endif
5348
-
}
5349
-
5350
5351
static void FreeShader(GPU_Renderer* renderer, Uint32 shader_object)
5351
5352
{
5352
5353
#ifndef SDL_GPU_DISABLE_SHADERS
···
5377
5378
if(IsFeatureEnabled(renderer, GPU_FEATURE_BASIC_SHADERS))
5378
5379
glDetachShader(program_object, shader_object);
5379
5380
#endif
5380
-
}
5381
-
5382
-
static Uint8 IsDefaultShaderProgram(GPU_Renderer* renderer, Uint32 program_object)
5383
-
{
5384
-
GPU_Context* context = renderer->current_context_target->context;
5385
-
return (program_object == context->default_textured_shader_program || program_object == context->default_untextured_shader_program);
5386
5381
}
5387
5382
5388
5383
static void ActivateShaderProgram(GPU_Renderer* renderer, Uint32 program_object, GPU_ShaderBlock* block)
···
6068
6063
\
6069
6064
impl->CompileShader_RW = &CompileShader_RW; \
6070
6065
impl->CompileShader = &CompileShader; \
6066
+
impl->CreateShaderProgram = &CreateShaderProgram; \
6071
6067
impl->LinkShaderProgram = &LinkShaderProgram; \
6072
-
impl->LinkShaders = &LinkShaders; \
6073
6068
impl->FreeShader = &FreeShader; \
6074
6069
impl->FreeShaderProgram = &FreeShaderProgram; \
6075
6070
impl->AttachShader = &AttachShader; \
6076
6071
impl->DetachShader = &DetachShader; \
6077
-
impl->IsDefaultShaderProgram = &IsDefaultShaderProgram; \
6078
6072
impl->ActivateShaderProgram = &ActivateShaderProgram; \
6079
6073
impl->DeactivateShaderProgram = &DeactivateShaderProgram; \
6080
6074
impl->GetShaderMessage = &GetShaderMessage; \
+29
-4
SDL_gpu/SDL_gpu.c
+29
-4
SDL_gpu/SDL_gpu.c
···
2285
2285
return current_renderer->impl->CompileShader(current_renderer, shader_type, shader_source);
2286
2286
}
2287
2287
2288
-
Uint32 GPU_LinkShaderProgram(Uint32 program_object)
2288
+
Uint8 GPU_LinkShaderProgram(Uint32 program_object)
2289
2289
{
2290
2290
if(current_renderer == NULL || current_renderer->current_context_target == NULL)
2291
2291
return 0;
···
2293
2293
return current_renderer->impl->LinkShaderProgram(current_renderer, program_object);
2294
2294
}
2295
2295
2296
+
Uint32 GPU_CreateShaderProgram(void)
2297
+
{
2298
+
if(current_renderer == NULL || current_renderer->current_context_target == NULL)
2299
+
return 0;
2300
+
2301
+
return current_renderer->impl->CreateShaderProgram(current_renderer);
2302
+
}
2303
+
2296
2304
Uint32 GPU_LinkShaders(Uint32 shader_object1, Uint32 shader_object2)
2297
2305
{
2306
+
Uint32 p;
2307
+
2298
2308
if(current_renderer == NULL || current_renderer->current_context_target == NULL)
2299
2309
return 0;
2300
2310
2301
-
return current_renderer->impl->LinkShaders(current_renderer, shader_object1, shader_object2);
2311
+
if((current_renderer->enabled_features & GPU_FEATURE_BASIC_SHADERS) != GPU_FEATURE_BASIC_SHADERS)
2312
+
return 0;
2313
+
2314
+
p = current_renderer->impl->CreateShaderProgram(current_renderer);
2315
+
2316
+
current_renderer->impl->AttachShader(current_renderer, p, shader_object1);
2317
+
current_renderer->impl->AttachShader(current_renderer, p, shader_object2);
2318
+
2319
+
if(current_renderer->impl->LinkShaderProgram(current_renderer, p))
2320
+
return p;
2321
+
2322
+
current_renderer->impl->FreeShaderProgram(current_renderer, p);
2323
+
return 0;
2302
2324
}
2303
2325
2304
2326
void GPU_FreeShader(Uint32 shader_object)
···
2335
2357
2336
2358
Uint8 GPU_IsDefaultShaderProgram(Uint32 program_object)
2337
2359
{
2360
+
GPU_Context* context;
2361
+
2338
2362
if(current_renderer == NULL || current_renderer->current_context_target == NULL)
2339
2363
return 0;
2340
-
2341
-
return current_renderer->impl->IsDefaultShaderProgram(current_renderer, program_object);
2364
+
2365
+
context = current_renderer->current_context_target->context;
2366
+
return (program_object == context->default_textured_shader_program || program_object == context->default_untextured_shader_program);
2342
2367
}
2343
2368
2344
2369
void GPU_ActivateShaderProgram(Uint32 program_object, GPU_ShaderBlock* block)
+35
-26
SDL_gpu/SDL_gpu.h
+35
-26
SDL_gpu/SDL_gpu.h
···
17
17
18
18
/* Auto-detect if we're using the SDL2 API by the headers available. */
19
19
#if SDL_VERSION_ATLEAST(2,0,0)
20
-
#define SDL_GPU_USE_SDL2
20
+
#define SDL_GPU_USE_SDL2
21
+
#else
22
+
#define SDL_GPU_USE_SDL1
21
23
#endif
22
24
23
25
typedef struct GPU_Renderer GPU_Renderer;
···
52
54
#define GPU_RENDERER_ORDER_MAX 10
53
55
54
56
typedef Uint32 GPU_RendererEnum;
55
-
static const GPU_RendererEnum GPU_RENDERER_UNKNOWN = 0x0; // invalid value
56
-
static const GPU_RendererEnum GPU_RENDERER_OPENGL_1_BASE = 0x1;
57
-
static const GPU_RendererEnum GPU_RENDERER_OPENGL_1 = 0x2;
58
-
static const GPU_RendererEnum GPU_RENDERER_OPENGL_2 = 0x4;
59
-
static const GPU_RendererEnum GPU_RENDERER_OPENGL_3 = 0x8;
60
-
static const GPU_RendererEnum GPU_RENDERER_OPENGL_4 = 0x10;
61
-
static const GPU_RendererEnum GPU_RENDERER_GLES_1 = 0x100;
62
-
static const GPU_RendererEnum GPU_RENDERER_GLES_2 = 0x200;
63
-
static const GPU_RendererEnum GPU_RENDERER_GLES_3 = 0x400;
64
-
static const GPU_RendererEnum GPU_RENDERER_D3D9 = 0x10000;
65
-
static const GPU_RendererEnum GPU_RENDERER_D3D10 = 0x20000;
66
-
static const GPU_RendererEnum GPU_RENDERER_D3D11 = 0x40000;
57
+
static const GPU_RendererEnum GPU_RENDERER_UNKNOWN = 0; // invalid value
58
+
static const GPU_RendererEnum GPU_RENDERER_OPENGL_1_BASE = 1;
59
+
static const GPU_RendererEnum GPU_RENDERER_OPENGL_1 = 2;
60
+
static const GPU_RendererEnum GPU_RENDERER_OPENGL_2 = 3;
61
+
static const GPU_RendererEnum GPU_RENDERER_OPENGL_3 = 4;
62
+
static const GPU_RendererEnum GPU_RENDERER_OPENGL_4 = 5;
63
+
static const GPU_RendererEnum GPU_RENDERER_GLES_1 = 11;
64
+
static const GPU_RendererEnum GPU_RENDERER_GLES_2 = 12;
65
+
static const GPU_RendererEnum GPU_RENDERER_GLES_3 = 13;
66
+
static const GPU_RendererEnum GPU_RENDERER_D3D9 = 21;
67
+
static const GPU_RendererEnum GPU_RENDERER_D3D10 = 22;
68
+
static const GPU_RendererEnum GPU_RENDERER_D3D11 = 23;
69
+
#define GPU_RENDERER_CUSTOM_0 1000
67
70
68
71
/*! \ingroup Initialization
69
72
* \ingroup RendererSetup
···
697
700
/*! Gets an array of identifiers for the registered (available) renderers. */
698
701
void GPU_GetRegisteredRendererList(GPU_RendererID* renderers_array);
699
702
700
-
/*! Creates a new renderer matching the given identifier. */
701
-
GPU_Renderer* GPU_AddRenderer(GPU_RendererID id);
702
-
703
-
/*! Deletes the renderer matching the given identifier. */
704
-
void GPU_RemoveRenderer(GPU_RendererID id);
703
+
/*! Prepares a renderer for use by SDL_gpu. */
704
+
void GPU_RegisterRenderer(GPU_RendererID id, GPU_Renderer* (*create_renderer)(GPU_RendererID request), void (*free_renderer)(GPU_Renderer* renderer));
705
705
706
706
// End of RendererSetup
707
707
/*! @} */
···
710
710
711
711
/*! \ingroup RendererControls
712
712
* @{ */
713
+
714
+
/*! Gets the next enum ID that can be used for a custom renderer. */
715
+
GPU_RendererEnum GPU_ReserveNextRendererEnum(void);
713
716
714
717
/*! Gets the number of active (created) renderers. */
715
718
int GPU_GetNumActiveRenderers(void);
···
1387
1390
/*! \ingroup ShaderInterface
1388
1391
* @{ */
1389
1392
1393
+
/*! Creates a new, empty shader program. You will need to compile shaders, attach them to the program, then link the program.
1394
+
* \see GPU_AttachShader
1395
+
* \see GPU_LinkShaderProgram
1396
+
*/
1397
+
Uint32 GPU_CreateShaderProgram(void);
1398
+
1399
+
/*! Deletes a shader program. */
1400
+
void GPU_FreeShaderProgram(Uint32 program_object);
1401
+
1390
1402
/*! Loads shader source from an SDL_RWops, compiles it, and returns the new shader object. */
1391
1403
Uint32 GPU_CompileShader_RW(GPU_ShaderEnum shader_type, SDL_RWops* shader_source);
1392
1404
1393
-
/*! Loads shader source from a file, compiles it, and returns the new shader object. */
1394
-
Uint32 GPU_LoadShader(GPU_ShaderEnum shader_type, const char* filename);
1395
-
1396
1405
/*! Compiles shader source and returns the new shader object. */
1397
1406
Uint32 GPU_CompileShader(GPU_ShaderEnum shader_type, const char* shader_source);
1398
1407
1399
-
/*! Links a shader program with any attached shader objects. */
1400
-
Uint32 GPU_LinkShaderProgram(Uint32 program_object);
1408
+
/*! Loads shader source from a file, compiles it, and returns the new shader object. */
1409
+
Uint32 GPU_LoadShader(GPU_ShaderEnum shader_type, const char* filename);
1401
1410
1402
1411
/*! Creates and links a shader program with the given shader objects. */
1403
1412
Uint32 GPU_LinkShaders(Uint32 shader_object1, Uint32 shader_object2);
···
1405
1414
/*! Deletes a shader object. */
1406
1415
void GPU_FreeShader(Uint32 shader_object);
1407
1416
1408
-
/*! Deletes a shader program. */
1409
-
void GPU_FreeShaderProgram(Uint32 program_object);
1410
-
1411
1417
/*! Attaches a shader object to a shader program for future linking. */
1412
1418
void GPU_AttachShader(Uint32 program_object, Uint32 shader_object);
1413
1419
1414
1420
/*! Detaches a shader object from a shader program. */
1415
1421
void GPU_DetachShader(Uint32 program_object, Uint32 shader_object);
1422
+
1423
+
/*! Links a shader program with any attached shader objects. */
1424
+
Uint8 GPU_LinkShaderProgram(Uint32 program_object);
1416
1425
1417
1426
/*! \return The current shader program */
1418
1427
Uint32 GPU_GetCurrentShaderProgram(void);
+37
-46
SDL_gpu/SDL_gpu_Renderer.c
+37
-46
SDL_gpu/SDL_gpu_Renderer.c
···
34
34
35
35
void GPU_InitRendererRegister(void);
36
36
37
+
38
+
GPU_RendererEnum GPU_ReserveNextRendererEnum(void)
39
+
{
40
+
static GPU_RendererEnum last_enum = GPU_RENDERER_CUSTOM_0;
41
+
return last_enum++;
42
+
}
43
+
37
44
int GPU_GetNumActiveRenderers(void)
38
45
{
39
46
int count;
···
125
132
GPU_Renderer* GPU_CreateRenderer_GLES_2(GPU_RendererID request);
126
133
void GPU_FreeRenderer_GLES_2(GPU_Renderer* renderer);
127
134
128
-
void GPU_RegisterRenderers()
135
+
void GPU_RegisterRenderer(GPU_RendererID id, GPU_Renderer* (*create_renderer)(GPU_RendererID request), void (*free_renderer)(GPU_Renderer* renderer))
129
136
{
130
-
int i = 0;
131
-
137
+
int i = GPU_GetNumRegisteredRenderers();
138
+
132
139
if(i >= MAX_REGISTERED_RENDERERS)
133
140
return;
134
-
141
+
142
+
id.index = i;
143
+
rendererRegister[i].id = id;
144
+
rendererRegister[i].createFn = create_renderer;
145
+
rendererRegister[i].freeFn = free_renderer;
146
+
}
147
+
148
+
void GPU_RegisterRenderers()
149
+
{
135
150
#ifndef SDL_GPU_DISABLE_OPENGL
136
151
#ifndef SDL_GPU_DISABLE_OPENGL_1_BASE
137
-
rendererRegister[i].id = makeRendererID(GPU_RENDERER_OPENGL_1_BASE, 1, 1, i);
138
-
rendererRegister[i].createFn = &GPU_CreateRenderer_OpenGL_1_BASE;
139
-
rendererRegister[i].freeFn = &GPU_FreeRenderer_OpenGL_1_BASE;
140
-
141
-
i++;
142
-
if(i >= MAX_REGISTERED_RENDERERS)
143
-
return;
152
+
GPU_RegisterRenderer(GPU_MakeRendererID(GPU_RENDERER_OPENGL_1_BASE, 1, 1),
153
+
&GPU_CreateRenderer_OpenGL_1_BASE,
154
+
&GPU_FreeRenderer_OpenGL_1_BASE);
144
155
#endif
145
156
146
157
#ifndef SDL_GPU_DISABLE_OPENGL_1
147
-
rendererRegister[i].id = makeRendererID(GPU_RENDERER_OPENGL_1, 1, 1, i);
148
-
rendererRegister[i].createFn = &GPU_CreateRenderer_OpenGL_1;
149
-
rendererRegister[i].freeFn = &GPU_FreeRenderer_OpenGL_1;
150
-
151
-
i++;
152
-
if(i >= MAX_REGISTERED_RENDERERS)
153
-
return;
158
+
GPU_RegisterRenderer(GPU_MakeRendererID(GPU_RENDERER_OPENGL_1, 1, 1),
159
+
&GPU_CreateRenderer_OpenGL_1,
160
+
&GPU_FreeRenderer_OpenGL_1);
154
161
#endif
155
162
156
163
#ifndef SDL_GPU_DISABLE_OPENGL_2
157
-
rendererRegister[i].id = makeRendererID(GPU_RENDERER_OPENGL_2, 2, 0, i);
158
-
rendererRegister[i].createFn = &GPU_CreateRenderer_OpenGL_2;
159
-
rendererRegister[i].freeFn = &GPU_FreeRenderer_OpenGL_2;
160
-
161
-
i++;
162
-
if(i >= MAX_REGISTERED_RENDERERS)
163
-
return;
164
+
GPU_RegisterRenderer(GPU_MakeRendererID(GPU_RENDERER_OPENGL_2, 2, 0),
165
+
&GPU_CreateRenderer_OpenGL_2,
166
+
&GPU_FreeRenderer_OpenGL_2);
164
167
#endif
165
168
166
169
#ifndef SDL_GPU_DISABLE_OPENGL_3
167
-
rendererRegister[i].id = makeRendererID(GPU_RENDERER_OPENGL_3, 3, 0, i);
168
-
rendererRegister[i].createFn = &GPU_CreateRenderer_OpenGL_3;
169
-
rendererRegister[i].freeFn = &GPU_FreeRenderer_OpenGL_3;
170
-
171
-
i++;
172
-
if(i >= MAX_REGISTERED_RENDERERS)
173
-
return;
170
+
GPU_RegisterRenderer(GPU_MakeRendererID(GPU_RENDERER_OPENGL_3, 3, 0),
171
+
&GPU_CreateRenderer_OpenGL_3,
172
+
&GPU_FreeRenderer_OpenGL_3);
174
173
#endif
175
174
#endif
176
175
177
176
#ifndef SDL_GPU_DISABLE_GLES
178
177
#ifndef SDL_GPU_DISABLE_GLES_1
179
-
rendererRegister[i].id = makeRendererID(GPU_RENDERER_GLES_1, 1, 1, i);
180
-
rendererRegister[i].createFn = &GPU_CreateRenderer_GLES_1;
181
-
rendererRegister[i].freeFn = &GPU_FreeRenderer_GLES_1;
182
-
183
-
i++;
184
-
if(i >= MAX_REGISTERED_RENDERERS)
185
-
return;
178
+
GPU_RegisterRenderer(GPU_MakeRendererID(GPU_RENDERER_GLES_1, 1, 1),
179
+
&GPU_CreateRenderer_GLES_1,
180
+
&GPU_FreeRenderer_GLES_1);
186
181
#endif
187
182
#ifndef SDL_GPU_DISABLE_GLES_2
188
-
rendererRegister[i].id = makeRendererID(GPU_RENDERER_GLES_2, 2, 0, i);
189
-
rendererRegister[i].createFn = &GPU_CreateRenderer_GLES_2;
190
-
rendererRegister[i].freeFn = &GPU_FreeRenderer_GLES_2;
191
-
192
-
i++;
193
-
if(i >= MAX_REGISTERED_RENDERERS)
194
-
return;
183
+
GPU_RegisterRenderer(GPU_MakeRendererID(GPU_RENDERER_GLES_2, 2, 0),
184
+
&GPU_CreateRenderer_GLES_2,
185
+
&GPU_FreeRenderer_GLES_2);
195
186
#endif
196
187
#endif
197
188
+21
-12
SDL_gpu/SDL_gpu_RendererImpl.h
+21
-12
SDL_gpu/SDL_gpu_RendererImpl.h
···
3
3
4
4
#include "SDL_gpu.h"
5
5
6
+
#ifdef __cplusplus
7
+
extern "C" {
8
+
#endif
9
+
10
+
// Internal API for managing window mappings
11
+
void GPU_AddWindowMapping(GPU_Target* target);
12
+
void GPU_RemoveWindowMapping(Uint32 windowID);
13
+
void GPU_RemoveWindowMappingByTarget(GPU_Target* target);
14
+
6
15
/*! Private implementation of renderer members. */
7
16
typedef struct GPU_RendererImpl
8
17
{
···
144
153
void (*Flip)(GPU_Renderer* renderer, GPU_Target* target);
145
154
146
155
156
+
/*! \see GPU_CreateShaderProgram() */
157
+
Uint32 (*CreateShaderProgram)(GPU_Renderer* renderer);
158
+
159
+
/*! \see GPU_FreeShaderProgram() */
160
+
void (*FreeShaderProgram)(GPU_Renderer* renderer, Uint32 program_object);
161
+
147
162
/*! \see GPU_CompileShader_RW() */
148
163
Uint32 (*CompileShader_RW)(GPU_Renderer* renderer, GPU_ShaderEnum shader_type, SDL_RWops* shader_source);
149
164
150
165
/*! \see GPU_CompileShader() */
151
166
Uint32 (*CompileShader)(GPU_Renderer* renderer, GPU_ShaderEnum shader_type, const char* shader_source);
152
167
153
-
/*! \see GPU_LinkShaderProgram() */
154
-
Uint32 (*LinkShaderProgram)(GPU_Renderer* renderer, Uint32 program_object);
155
-
156
-
/*! \see GPU_LinkShaders() */
157
-
Uint32 (*LinkShaders)(GPU_Renderer* renderer, Uint32 shader_object1, Uint32 shader_object2);
158
-
159
168
/*! \see GPU_FreeShader() */
160
169
void (*FreeShader)(GPU_Renderer* renderer, Uint32 shader_object);
161
-
162
-
/*! \see GPU_FreeShaderProgram() */
163
-
void (*FreeShaderProgram)(GPU_Renderer* renderer, Uint32 program_object);
164
170
165
171
/*! \see GPU_AttachShader() */
166
172
void (*AttachShader)(GPU_Renderer* renderer, Uint32 program_object, Uint32 shader_object);
167
173
168
174
/*! \see GPU_DetachShader() */
169
175
void (*DetachShader)(GPU_Renderer* renderer, Uint32 program_object, Uint32 shader_object);
170
-
171
-
/*! \see GPU_IsDefaultShaderProgram() */
172
-
Uint8 (*IsDefaultShaderProgram)(GPU_Renderer* renderer, Uint32 program_object);
176
+
177
+
/*! \see GPU_LinkShaderProgram() */
178
+
Uint8 (*LinkShaderProgram)(GPU_Renderer* renderer, Uint32 program_object);
173
179
174
180
/*! \see GPU_ActivateShaderProgram() */
175
181
void (*ActivateShaderProgram)(GPU_Renderer* renderer, Uint32 program_object, GPU_ShaderBlock* block);
···
311
317
312
318
} GPU_RendererImpl;
313
319
320
+
#ifdef __cplusplus
321
+
}
322
+
#endif
314
323
315
324
#endif
+3
demos/CMakeLists.txt
+3
demos/CMakeLists.txt
···
125
125
add_executable(sandbox-demo sandbox/main.c common/common.c common/demo-font.c)
126
126
target_link_libraries (sandbox-demo SDL_gpu)
127
127
128
+
add_executable(renderer-demo renderer/main.c common/common.c)
129
+
target_link_libraries (renderer-demo SDL_gpu)
130
+
128
131
add_executable(video-demo video/main.c common/common.c common/demo-font.c)
129
132
target_link_libraries (video-demo SDL_gpu)
+1387
demos/renderer/main.c
+1387
demos/renderer/main.c
···
1
+
#include "SDL.h"
2
+
#include "SDL_gpu.h"
3
+
#include "SDL_gpu_RendererImpl.h"
4
+
#include "common.h"
5
+
6
+
7
+
#ifdef _MSC_VER
8
+
#define __func__ __FUNCTION__
9
+
#endif
10
+
11
+
12
+
#ifdef SDL_GPU_USE_SDL1
13
+
// This demo doesn't work for SDL 1.2 because of the assumed windowing features here.
14
+
int main(int argc, char* argv[])
15
+
{
16
+
GPU_LogError("Sorry, this demo requires SDL 2.\n");
17
+
return 0;
18
+
}
19
+
20
+
#else
21
+
22
+
// Custom renderer implementation
23
+
/*
24
+
Notes:
25
+
- Every function must be implemented (even just a dummy implementation is fine).
26
+
SDL_gpu does not do NULL checks on the renderer implementation function pointers because it is better to have to
27
+
copy and paste a bunch of dummy functions than to force every good renderer to do extra NULL checks.
28
+
- When SDL_gpu calls one of these functions internally, 'renderer' and 'renderer->current_context_target' will never be NULL.
29
+
- Since each of these calls needs a renderer, SDL_gpu will always be using the current active renderer.
30
+
- These dummy implementations do not always flush the blit buffer as needed by real renderers. This is because the dummy has no storage for renderer-specific state changes.
31
+
*/
32
+
33
+
static GPU_Target* Init(GPU_Renderer* renderer, GPU_RendererID renderer_request, Uint16 w, Uint16 h, GPU_WindowFlagEnum SDL_flags)
34
+
{
35
+
SDL_Window* window;
36
+
37
+
GPU_Log(" %s (dummy)\n", __func__);
38
+
39
+
renderer->requested_id = renderer_request;
40
+
renderer->GPU_init_flags = GPU_GetPreInitFlags();
41
+
renderer->SDL_init_flags = SDL_flags;
42
+
43
+
window = NULL;
44
+
// Is there a window already set up that we are supposed to use?
45
+
if(renderer->current_context_target != NULL)
46
+
window = SDL_GetWindowFromID(renderer->current_context_target->context->windowID);
47
+
else
48
+
window = SDL_GetWindowFromID(GPU_GetInitWindow());
49
+
50
+
if(window == NULL)
51
+
{
52
+
// Set up window flags
53
+
if(!(renderer->SDL_init_flags & SDL_WINDOW_HIDDEN))
54
+
renderer->SDL_init_flags |= SDL_WINDOW_SHOWN;
55
+
56
+
window = SDL_CreateWindow("",
57
+
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
58
+
w, h,
59
+
renderer->SDL_init_flags);
60
+
61
+
if(window == NULL)
62
+
{
63
+
GPU_PushErrorCode("GPU_Init", GPU_ERROR_BACKEND_ERROR, "Window creation failed.");
64
+
return NULL;
65
+
}
66
+
67
+
GPU_SetInitWindow(SDL_GetWindowID(window));
68
+
}
69
+
else
70
+
renderer->SDL_init_flags = SDL_flags;
71
+
72
+
renderer->enabled_features = 0xFFFFFFFF; // Pretend to support them all
73
+
74
+
renderer->current_context_target = renderer->impl->CreateTargetFromWindow(renderer, SDL_GetWindowID(window), renderer->current_context_target);
75
+
if(renderer->current_context_target == NULL)
76
+
return NULL;
77
+
78
+
79
+
// If the dimensions of the window don't match what we asked for, then set up a virtual resolution to pretend like they are.
80
+
if(!(renderer->GPU_init_flags & GPU_INIT_DISABLE_AUTO_VIRTUAL_RESOLUTION) && w != 0 && h != 0 && (w != renderer->current_context_target->w || h != renderer->current_context_target->h))
81
+
renderer->impl->SetVirtualResolution(renderer, renderer->current_context_target, w, h);
82
+
83
+
return renderer->current_context_target;
84
+
}
85
+
86
+
static GPU_Target* CreateTargetFromWindow(GPU_Renderer* renderer, Uint32 windowID, GPU_Target* target)
87
+
{
88
+
GPU_Log(" %s (dummy)\n", __func__);
89
+
90
+
if(target == NULL)
91
+
{
92
+
target = (GPU_Target*)malloc(sizeof(GPU_Target*));
93
+
memset(target, 0, sizeof(GPU_Target));
94
+
95
+
target->refcount = 1;
96
+
target->is_alias = 0;
97
+
target->data = NULL; // Allocate a data structure as needed for other render target data
98
+
target->image = NULL;
99
+
100
+
target->context = (GPU_Context*)malloc(sizeof(GPU_Context));
101
+
memset(target->context, 0, sizeof(GPU_Context));
102
+
103
+
target->context->windowID = windowID;
104
+
target->context->data = NULL; // Allocate a data structure as needed for other context data
105
+
target->context->context = NULL;
106
+
}
107
+
else
108
+
{
109
+
GPU_RemoveWindowMapping(target->context->windowID);
110
+
}
111
+
112
+
// This is used for restoring window after fullscreen switches
113
+
SDL_GetWindowSize(SDL_GetWindowFromID(target->context->windowID), &target->context->window_w, &target->context->window_h);
114
+
target->context->stored_window_w = target->context->window_w;
115
+
target->context->stored_window_h = target->context->window_h;
116
+
117
+
GPU_AddWindowMapping(target);
118
+
119
+
120
+
target->renderer = renderer;
121
+
target->w = target->context->window_w;
122
+
target->h = target->context->window_h;
123
+
target->base_w = target->context->window_w;
124
+
target->base_h = target->context->window_h;
125
+
126
+
target->use_clip_rect = 0;
127
+
target->clip_rect.x = 0;
128
+
target->clip_rect.y = 0;
129
+
target->clip_rect.w = target->w;
130
+
target->clip_rect.h = target->h;
131
+
target->use_color = 0;
132
+
133
+
target->viewport = GPU_MakeRect(0, 0, target->context->window_w, target->context->window_h);
134
+
target->camera = GPU_GetDefaultCamera();
135
+
136
+
target->context->line_thickness = 1.0f;
137
+
target->context->use_texturing = 1;
138
+
target->context->shapes_use_blending = 1;
139
+
target->context->shapes_blend_mode = GPU_GetBlendModeFromPreset(GPU_BLEND_NORMAL);
140
+
141
+
target->context->projection_matrix.size = 1;
142
+
GPU_MatrixIdentity(target->context->projection_matrix.matrix[0]);
143
+
144
+
target->context->modelview_matrix.size = 1;
145
+
GPU_MatrixIdentity(target->context->modelview_matrix.matrix[0]);
146
+
147
+
target->context->matrix_mode = GPU_MODELVIEW;
148
+
149
+
150
+
renderer->impl->SetLineThickness(renderer, 1.0f);
151
+
152
+
153
+
target->context->default_textured_shader_program = 0;
154
+
target->context->default_untextured_shader_program = 0;
155
+
target->context->current_shader_program = 0;
156
+
157
+
return target;
158
+
}
159
+
160
+
static GPU_Target* CreateAliasTarget(GPU_Renderer* renderer, GPU_Target* target)
161
+
{
162
+
GPU_Target* result;
163
+
164
+
GPU_Log(" %s (dummy)\n", __func__);
165
+
166
+
if(target == NULL)
167
+
return NULL;
168
+
169
+
result = (GPU_Target*)malloc(sizeof(GPU_Target));
170
+
171
+
// Copy the members
172
+
*result = *target;
173
+
174
+
// Alias info
175
+
if(target->image != NULL)
176
+
target->image->refcount++;
177
+
result->refcount = 1;
178
+
result->is_alias = 1;
179
+
180
+
return result;
181
+
}
182
+
183
+
static void MakeCurrent(GPU_Renderer* renderer, GPU_Target* target, Uint32 windowID)
184
+
{
185
+
GPU_Log(" %s (dummy)\n", __func__);
186
+
187
+
if(target == NULL || target->context == NULL)
188
+
return;
189
+
190
+
renderer->current_context_target = target;
191
+
192
+
// Reset if the target's window was changed
193
+
if(target->context->windowID != windowID)
194
+
{
195
+
// Update the window mappings
196
+
GPU_RemoveWindowMapping(windowID);
197
+
// Don't remove the target's current mapping. That lets other windows refer to it.
198
+
target->context->windowID = windowID;
199
+
GPU_AddWindowMapping(target);
200
+
201
+
// Update target's window size
202
+
SDL_GetWindowSize(SDL_GetWindowFromID(windowID), &target->context->window_w, &target->context->window_h);
203
+
target->base_w = target->context->window_w;
204
+
target->base_h = target->context->window_h;
205
+
206
+
// Reset the camera here for this window
207
+
}
208
+
}
209
+
210
+
static void SetAsCurrent(GPU_Renderer* renderer)
211
+
{
212
+
GPU_Log(" %s (dummy)\n", __func__);
213
+
214
+
if(renderer->current_context_target == NULL)
215
+
return;
216
+
217
+
renderer->impl->MakeCurrent(renderer, renderer->current_context_target, renderer->current_context_target->context->windowID);
218
+
}
219
+
220
+
static void ResetRendererState(GPU_Renderer* renderer)
221
+
{
222
+
GPU_Log(" %s (dummy)\n", __func__);
223
+
}
224
+
225
+
static Uint8 SetWindowResolution(GPU_Renderer* renderer, Uint16 w, Uint16 h)
226
+
{
227
+
GPU_Target* target = renderer->current_context_target;
228
+
229
+
GPU_Log(" %s (dummy)\n", __func__);
230
+
231
+
if(target == NULL)
232
+
return 0;
233
+
234
+
// Don't need to resize (only update internals) when resolution isn't changing.
235
+
SDL_GetWindowSize(SDL_GetWindowFromID(target->context->windowID), &target->context->window_w, &target->context->window_h);
236
+
if(target->context->window_w != w || target->context->window_h != h)
237
+
{
238
+
SDL_SetWindowSize(SDL_GetWindowFromID(target->context->windowID), w, h);
239
+
SDL_GetWindowSize(SDL_GetWindowFromID(target->context->windowID), &target->context->window_w, &target->context->window_h);
240
+
}
241
+
242
+
// Store the resolution for fullscreen_desktop changes
243
+
target->context->stored_window_w = target->context->window_w;
244
+
target->context->stored_window_h = target->context->window_h;
245
+
246
+
// Update base dimensions
247
+
target->base_w = target->context->window_w;
248
+
target->base_h = target->context->window_h;
249
+
250
+
// Resets virtual resolution
251
+
target->w = target->base_w;
252
+
target->h = target->base_h;
253
+
target->using_virtual_resolution = 0;
254
+
255
+
return 1;
256
+
}
257
+
258
+
static void SetVirtualResolution(GPU_Renderer* renderer, GPU_Target* target, Uint16 w, Uint16 h)
259
+
{
260
+
GPU_Log(" %s (dummy)\n", __func__);
261
+
262
+
if(target == NULL)
263
+
return;
264
+
265
+
target->w = w;
266
+
target->h = h;
267
+
target->using_virtual_resolution = 1;
268
+
}
269
+
270
+
271
+
static void UnsetVirtualResolution(GPU_Renderer* renderer, GPU_Target* target)
272
+
{
273
+
GPU_Log(" %s (dummy)\n", __func__);
274
+
275
+
if(target == NULL)
276
+
return;
277
+
278
+
target->w = target->base_w;
279
+
target->h = target->base_h;
280
+
target->using_virtual_resolution = 0;
281
+
}
282
+
283
+
284
+
static void Quit(GPU_Renderer* renderer)
285
+
{
286
+
GPU_Log(" %s (dummy)\n", __func__);
287
+
288
+
renderer->impl->FreeTarget(renderer, renderer->current_context_target);
289
+
renderer->current_context_target = NULL;
290
+
}
291
+
292
+
293
+
static Uint8 SetFullscreen(GPU_Renderer* renderer, Uint8 enable_fullscreen, Uint8 use_desktop_resolution)
294
+
{
295
+
GPU_Target* target = renderer->current_context_target;
296
+
297
+
// These values should actually come from the window
298
+
Uint8 was_fullscreen = !enable_fullscreen;
299
+
Uint8 is_fullscreen = enable_fullscreen;
300
+
301
+
GPU_Log(" %s (dummy)\n", __func__);
302
+
303
+
//if(SetWindowFullscreen(target->context->windowID, enable_fullscreen) >= 0)
304
+
{
305
+
// If we just went fullscreen, save the original resolution
306
+
// We do this because you can't depend on the resolution to be preserved by SDL
307
+
// SDL_WINDOW_FULLSCREEN_DESKTOP changes the resolution and SDL_WINDOW_FULLSCREEN can change it when a given mode is not available
308
+
if(!was_fullscreen && is_fullscreen)
309
+
{
310
+
target->context->stored_window_w = target->context->window_w;
311
+
target->context->stored_window_h = target->context->window_h;
312
+
}
313
+
314
+
// If we're in windowed mode now and a resolution was stored, restore the original window resolution
315
+
if(was_fullscreen && !is_fullscreen && (target->context->stored_window_w != 0 && target->context->stored_window_h != 0))
316
+
SDL_SetWindowSize(SDL_GetWindowFromID(target->context->windowID), target->context->stored_window_w, target->context->stored_window_h);
317
+
318
+
// Update window dims
319
+
SDL_GetWindowSize(SDL_GetWindowFromID(target->context->windowID), &target->context->window_w, &target->context->window_h);
320
+
}
321
+
322
+
if(is_fullscreen != was_fullscreen)
323
+
{
324
+
// If virtual res is not set, we need to update the target dims and reset stuff that no longer is right
325
+
if(!target->using_virtual_resolution)
326
+
{
327
+
// Update dims
328
+
target->w = target->context->window_w;
329
+
target->h = target->context->window_h;
330
+
}
331
+
332
+
// Reset viewport
333
+
target->viewport = GPU_MakeRect(0, 0, target->context->window_w, target->context->window_h);
334
+
// Update viewport here
335
+
336
+
// Reset clip
337
+
GPU_UnsetClip(target);
338
+
339
+
// Update camera here
340
+
}
341
+
342
+
target->base_w = target->context->window_w;
343
+
target->base_h = target->context->window_h;
344
+
345
+
return is_fullscreen;
346
+
}
347
+
348
+
349
+
static GPU_Camera SetCamera(GPU_Renderer* renderer, GPU_Target* target, GPU_Camera* cam)
350
+
{
351
+
GPU_Camera new_camera;
352
+
GPU_Camera old_camera;
353
+
354
+
GPU_Log(" %s (dummy)\n", __func__);
355
+
356
+
if(target == NULL)
357
+
{
358
+
GPU_PushErrorCode("GPU_SetCamera", GPU_ERROR_NULL_ARGUMENT, "target");
359
+
return GPU_GetDefaultCamera();
360
+
}
361
+
362
+
if(cam == NULL)
363
+
new_camera = GPU_GetDefaultCamera();
364
+
else
365
+
new_camera = *cam;
366
+
367
+
old_camera = target->camera;
368
+
target->camera = new_camera;
369
+
370
+
return old_camera;
371
+
}
372
+
373
+
374
+
static GPU_Image* CreateImage(GPU_Renderer* renderer, Uint16 w, Uint16 h, GPU_FormatEnum format)
375
+
{
376
+
int num_layers, bytes_per_pixel;
377
+
GPU_Image* result;
378
+
SDL_Color white = { 255, 255, 255, 255 };
379
+
380
+
GPU_Log(" %s (dummy)\n", __func__);
381
+
382
+
if(format < 1)
383
+
{
384
+
GPU_PushErrorCode("GPU_CreateImage", GPU_ERROR_DATA_ERROR, "Unsupported image format (0x%x)", format);
385
+
return NULL;
386
+
}
387
+
388
+
389
+
switch(format)
390
+
{
391
+
case GPU_FORMAT_LUMINANCE:
392
+
num_layers = 1;
393
+
bytes_per_pixel = 1;
394
+
break;
395
+
case GPU_FORMAT_LUMINANCE_ALPHA:
396
+
num_layers = 1;
397
+
bytes_per_pixel = 2;
398
+
break;
399
+
case GPU_FORMAT_RGB:
400
+
num_layers = 1;
401
+
bytes_per_pixel = 3;
402
+
break;
403
+
case GPU_FORMAT_RGBA:
404
+
num_layers = 1;
405
+
bytes_per_pixel = 4;
406
+
break;
407
+
case GPU_FORMAT_ALPHA:
408
+
num_layers = 1;
409
+
bytes_per_pixel = 1;
410
+
break;
411
+
case GPU_FORMAT_RG:
412
+
num_layers = 1;
413
+
bytes_per_pixel = 2;
414
+
break;
415
+
case GPU_FORMAT_YCbCr420P:
416
+
num_layers = 3;
417
+
bytes_per_pixel = 1;
418
+
break;
419
+
case GPU_FORMAT_YCbCr422:
420
+
num_layers = 3;
421
+
bytes_per_pixel = 1;
422
+
break;
423
+
default:
424
+
GPU_PushErrorCode("GPU_CreateUninitializedImage", GPU_ERROR_DATA_ERROR, "Unsupported image format (0x%x)", format);
425
+
return NULL;
426
+
}
427
+
428
+
if(bytes_per_pixel < 1 || bytes_per_pixel > 4)
429
+
{
430
+
GPU_PushErrorCode("GPU_CreateUninitializedImage", GPU_ERROR_DATA_ERROR, "Unsupported number of bytes per pixel (%d)", bytes_per_pixel);
431
+
return NULL;
432
+
}
433
+
434
+
result = (GPU_Image*)malloc(sizeof(GPU_Image));
435
+
result->refcount = 1;
436
+
result->target = NULL;
437
+
result->renderer = renderer;
438
+
result->format = format;
439
+
result->num_layers = num_layers;
440
+
result->bytes_per_pixel = bytes_per_pixel;
441
+
result->has_mipmaps = 0;
442
+
443
+
result->color = white;
444
+
result->use_blending = ((format == GPU_FORMAT_LUMINANCE_ALPHA || format == GPU_FORMAT_RGBA)? 1 : 0);
445
+
result->blend_mode = GPU_GetBlendModeFromPreset(GPU_BLEND_NORMAL);
446
+
result->filter_mode = GPU_FILTER_LINEAR;
447
+
result->snap_mode = GPU_SNAP_POSITION_AND_DIMENSIONS;
448
+
result->wrap_mode_x = GPU_WRAP_NONE;
449
+
result->wrap_mode_y = GPU_WRAP_NONE;
450
+
451
+
result->data = NULL; // Allocate a data structure as needed for other image data
452
+
result->is_alias = 0;
453
+
454
+
result->w = w;
455
+
result->h = h;
456
+
457
+
result->base_w = w;
458
+
result->base_h = h;
459
+
460
+
return result;
461
+
}
462
+
463
+
464
+
static GPU_Image* CreateImageUsingTexture(GPU_Renderer* renderer, Uint32 handle, Uint8 take_ownership)
465
+
{
466
+
GPU_Log(" %s (dummy)\n", __func__);
467
+
468
+
return renderer->impl->CreateImage(renderer, 100, 100, GPU_FORMAT_RGBA);
469
+
}
470
+
471
+
472
+
static GPU_Image* LoadImage(GPU_Renderer* renderer, const char* filename)
473
+
{
474
+
GPU_Log(" %s (dummy)\n", __func__);
475
+
476
+
return renderer->impl->CreateImage(renderer, 100, 100, GPU_FORMAT_RGBA);
477
+
}
478
+
479
+
480
+
static GPU_Image* CreateAliasImage(GPU_Renderer* renderer, GPU_Image* image)
481
+
{
482
+
GPU_Image* result;
483
+
484
+
GPU_Log(" %s (dummy)\n", __func__);
485
+
486
+
if(image == NULL)
487
+
return NULL;
488
+
489
+
result = (GPU_Image*)malloc(sizeof(GPU_Image));
490
+
// Copy the members
491
+
*result = *image;
492
+
493
+
// Alias info
494
+
result->refcount = 1;
495
+
result->is_alias = 1;
496
+
497
+
return result;
498
+
}
499
+
500
+
501
+
static Uint8 SaveImage(GPU_Renderer* renderer, GPU_Image* image, const char* filename)
502
+
{
503
+
GPU_Log(" %s (dummy)\n", __func__);
504
+
505
+
return 1;
506
+
}
507
+
508
+
509
+
static GPU_Image* CopyImage(GPU_Renderer* renderer, GPU_Image* image)
510
+
{
511
+
GPU_Log(" %s (dummy)\n", __func__);
512
+
513
+
if(image == NULL)
514
+
return NULL;
515
+
516
+
return renderer->impl->CreateImage(renderer, image->w, image->h, image->format);
517
+
}
518
+
519
+
520
+
static void UpdateImage(GPU_Renderer* renderer, GPU_Image* image, SDL_Surface* surface, const GPU_Rect* surface_rect)
521
+
{
522
+
GPU_Log(" %s (dummy)\n", __func__);
523
+
}
524
+
525
+
526
+
static void UpdateSubImage(GPU_Renderer* renderer, GPU_Image* image, const GPU_Rect* image_rect, SDL_Surface* surface, const GPU_Rect* surface_rect)
527
+
{
528
+
GPU_Log(" %s (dummy)\n", __func__);
529
+
}
530
+
531
+
532
+
static void UpdateImageBytes(GPU_Renderer* renderer, GPU_Image* image, const GPU_Rect* image_rect, const unsigned char* bytes, int bytes_per_row)
533
+
{
534
+
GPU_Log(" %s (dummy)\n", __func__);
535
+
}
536
+
537
+
538
+
static GPU_Image* CopyImageFromSurface(GPU_Renderer* renderer, SDL_Surface* surface)
539
+
{
540
+
GPU_Log(" %s (dummy)\n", __func__);
541
+
542
+
if(surface == NULL)
543
+
return NULL;
544
+
545
+
return renderer->impl->CreateImage(renderer, surface->w, surface->h, GPU_FORMAT_RGBA);
546
+
}
547
+
548
+
549
+
static GPU_Image* CopyImageFromTarget(GPU_Renderer* renderer, GPU_Target* target)
550
+
{
551
+
GPU_Log(" %s (dummy)\n", __func__);
552
+
553
+
if(target == NULL)
554
+
return NULL;
555
+
556
+
return renderer->impl->CreateImage(renderer, target->w, target->h, GPU_FORMAT_RGBA);
557
+
}
558
+
559
+
560
+
static SDL_Surface* CopySurfaceFromTarget(GPU_Renderer* renderer, GPU_Target* target)
561
+
{
562
+
GPU_Log(" %s (dummy)\n", __func__);
563
+
564
+
if(target == NULL)
565
+
return NULL;
566
+
567
+
return SDL_CreateRGBSurface(SDL_SWSURFACE, target->base_w, target->base_h, 32, 0, 0, 0, 0);
568
+
}
569
+
570
+
571
+
static SDL_Surface* CopySurfaceFromImage(GPU_Renderer* renderer, GPU_Image* image)
572
+
{
573
+
GPU_Log(" %s (dummy)\n", __func__);
574
+
575
+
if(image == NULL)
576
+
return NULL;
577
+
578
+
return SDL_CreateRGBSurface(SDL_SWSURFACE, image->base_w, image->base_h, 32, 0, 0, 0, 0);
579
+
}
580
+
581
+
582
+
static void FreeImage(GPU_Renderer* renderer, GPU_Image* image)
583
+
{
584
+
GPU_Log(" %s (dummy)\n", __func__);
585
+
586
+
if(image == NULL)
587
+
return;
588
+
589
+
if(image->refcount > 1)
590
+
{
591
+
image->refcount--;
592
+
return;
593
+
}
594
+
595
+
// Delete the attached target first
596
+
if(image->target != NULL)
597
+
{
598
+
GPU_Target* target = image->target;
599
+
image->target = NULL;
600
+
renderer->impl->FreeTarget(renderer, target);
601
+
}
602
+
603
+
free(image);
604
+
}
605
+
606
+
607
+
static GPU_Target* LoadTarget(GPU_Renderer* renderer, GPU_Image* image)
608
+
{
609
+
GPU_Target* result;
610
+
611
+
GPU_Log(" %s (dummy)\n", __func__);
612
+
613
+
if(image == NULL)
614
+
return NULL;
615
+
616
+
if(image->target != NULL)
617
+
{
618
+
image->target->refcount++;
619
+
return image->target;
620
+
}
621
+
622
+
if(!(renderer->enabled_features & GPU_FEATURE_RENDER_TARGETS))
623
+
return NULL;
624
+
625
+
result = (GPU_Target*)malloc(sizeof(GPU_Target));
626
+
memset(result, 0, sizeof(GPU_Target));
627
+
result->refcount = 1;
628
+
result->data = NULL; // Allocate a data structure as needed for other render target data
629
+
630
+
result->renderer = renderer;
631
+
result->context = NULL;
632
+
result->image = image;
633
+
result->w = image->w;
634
+
result->h = image->h;
635
+
result->base_w = image->base_w;
636
+
result->base_h = image->base_h;
637
+
638
+
result->viewport = GPU_MakeRect(0, 0, result->w, result->h);
639
+
640
+
result->camera = GPU_GetDefaultCamera();
641
+
642
+
result->use_clip_rect = 0;
643
+
result->clip_rect.x = 0;
644
+
result->clip_rect.y = 0;
645
+
result->clip_rect.w = result->w;
646
+
result->clip_rect.h = result->h;
647
+
result->use_color = 0;
648
+
649
+
image->target = result;
650
+
return result;
651
+
}
652
+
653
+
654
+
static void FreeTarget(GPU_Renderer* renderer, GPU_Target* target)
655
+
{
656
+
GPU_Log(" %s (dummy)\n", __func__);
657
+
658
+
if(target == NULL)
659
+
return;
660
+
661
+
if(target->refcount > 1)
662
+
{
663
+
target->refcount--;
664
+
return;
665
+
}
666
+
667
+
if(target->context != NULL && target->context->failed)
668
+
{
669
+
if(target == renderer->current_context_target)
670
+
renderer->current_context_target = NULL;
671
+
672
+
// Remove all of the window mappings that refer to this target
673
+
GPU_RemoveWindowMappingByTarget(target);
674
+
675
+
free(target->context);
676
+
free(target);
677
+
return;
678
+
}
679
+
680
+
if(target == renderer->current_context_target)
681
+
{
682
+
renderer->impl->FlushBlitBuffer(renderer);
683
+
renderer->current_context_target = NULL;
684
+
}
685
+
686
+
if(!target->is_alias && target->image != NULL)
687
+
target->image->target = NULL; // Remove reference to this object
688
+
689
+
if(target->context != NULL)
690
+
{
691
+
// Remove all of the window mappings that refer to this target
692
+
GPU_RemoveWindowMappingByTarget(target);
693
+
694
+
free(target->context);
695
+
target->context = NULL;
696
+
}
697
+
698
+
free(target);
699
+
}
700
+
701
+
702
+
static void Blit(GPU_Renderer* renderer, GPU_Image* image, GPU_Rect* src_rect, GPU_Target* target, float x, float y)
703
+
{
704
+
GPU_Log(" %s (dummy)\n", __func__);
705
+
}
706
+
707
+
708
+
static void BlitRotate(GPU_Renderer* renderer, GPU_Image* image, GPU_Rect* src_rect, GPU_Target* target, float x, float y, float degrees)
709
+
{
710
+
GPU_Log(" %s (dummy)\n", __func__);
711
+
}
712
+
713
+
714
+
static void BlitScale(GPU_Renderer* renderer, GPU_Image* image, GPU_Rect* src_rect, GPU_Target* target, float x, float y, float scaleX, float scaleY)
715
+
{
716
+
GPU_Log(" %s (dummy)\n", __func__);
717
+
}
718
+
719
+
720
+
static void BlitTransform(GPU_Renderer* renderer, GPU_Image* image, GPU_Rect* src_rect, GPU_Target* target, float x, float y, float degrees, float scaleX, float scaleY)
721
+
{
722
+
GPU_Log(" %s (dummy)\n", __func__);
723
+
}
724
+
725
+
726
+
static void BlitTransformX(GPU_Renderer* renderer, GPU_Image* image, GPU_Rect* src_rect, GPU_Target* target, float x, float y, float pivot_x, float pivot_y, float degrees, float scaleX, float scaleY)
727
+
{
728
+
GPU_Log(" %s (dummy)\n", __func__);
729
+
}
730
+
731
+
732
+
static void BlitTransformMatrix(GPU_Renderer* renderer, GPU_Image* image, GPU_Rect* src_rect, GPU_Target* target, float x, float y, float* matrix3x3)
733
+
{
734
+
GPU_Log(" %s (dummy)\n", __func__);
735
+
}
736
+
737
+
738
+
static void BlitBatch(GPU_Renderer* renderer, GPU_Image* image, GPU_Target* target, unsigned int num_sprites, float* values, GPU_BlitFlagEnum flags)
739
+
{
740
+
GPU_Log(" %s (dummy)\n", __func__);
741
+
}
742
+
743
+
744
+
static void TriangleBatch(GPU_Renderer* renderer, GPU_Image* image, GPU_Target* target, unsigned short num_vertices, float* values, unsigned int num_indices, unsigned short* indices, GPU_BlitFlagEnum flags)
745
+
{
746
+
GPU_Log(" %s (dummy)\n", __func__);
747
+
}
748
+
749
+
750
+
static void GenerateMipmaps(GPU_Renderer* renderer, GPU_Image* image)
751
+
{
752
+
GPU_Log(" %s (dummy)\n", __func__);
753
+
}
754
+
755
+
756
+
static GPU_Rect SetClip(GPU_Renderer* renderer, GPU_Target* target, Sint16 x, Sint16 y, Uint16 w, Uint16 h)
757
+
{
758
+
GPU_Rect r;
759
+
760
+
GPU_Log(" %s (dummy)\n", __func__);
761
+
762
+
if(target == NULL)
763
+
{
764
+
GPU_Rect r = {0,0,0,0};
765
+
return r;
766
+
}
767
+
768
+
target->use_clip_rect = 1;
769
+
770
+
r = target->clip_rect;
771
+
772
+
target->clip_rect.x = x;
773
+
target->clip_rect.y = y;
774
+
target->clip_rect.w = w;
775
+
target->clip_rect.h = h;
776
+
777
+
return r;
778
+
}
779
+
780
+
781
+
static void UnsetClip(GPU_Renderer* renderer, GPU_Target* target)
782
+
{
783
+
GPU_Log(" %s (dummy)\n", __func__);
784
+
785
+
target->use_clip_rect = 0;
786
+
}
787
+
788
+
789
+
static SDL_Color GetPixel(GPU_Renderer* renderer, GPU_Target* target, Sint16 x, Sint16 y)
790
+
{
791
+
GPU_Log(" %s (dummy)\n", __func__);
792
+
793
+
return GPU_MakeColor(0, 0, 0, 0);
794
+
}
795
+
796
+
797
+
static void SetImageFilter(GPU_Renderer* renderer, GPU_Image* image, GPU_FilterEnum filter)
798
+
{
799
+
GPU_Log(" %s (dummy)\n", __func__);
800
+
801
+
image->filter_mode = filter;
802
+
}
803
+
804
+
805
+
static void SetWrapMode(GPU_Renderer* renderer, GPU_Image* image, GPU_WrapEnum wrap_mode_x, GPU_WrapEnum wrap_mode_y)
806
+
{
807
+
GPU_Log(" %s (dummy)\n", __func__);
808
+
809
+
image->wrap_mode_x = wrap_mode_x;
810
+
image->wrap_mode_y = wrap_mode_y;
811
+
}
812
+
813
+
814
+
static void ClearRGBA(GPU_Renderer* renderer, GPU_Target* target, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
815
+
{
816
+
GPU_Log(" %s (dummy)\n", __func__);
817
+
}
818
+
819
+
static void FlushBlitBuffer(GPU_Renderer* renderer)
820
+
{
821
+
GPU_Log(" %s (dummy)\n", __func__);
822
+
}
823
+
824
+
static void Flip(GPU_Renderer* renderer, GPU_Target* target)
825
+
{
826
+
GPU_Log(" %s (dummy)\n", __func__);
827
+
}
828
+
829
+
static Uint32 CreateShaderProgram(GPU_Renderer* renderer)
830
+
{
831
+
GPU_Log(" %s (dummy)\n", __func__);
832
+
833
+
return 0;
834
+
}
835
+
836
+
static void FreeShaderProgram(GPU_Renderer* renderer, Uint32 program_object)
837
+
{
838
+
GPU_Log(" %s (dummy)\n", __func__);
839
+
}
840
+
841
+
static Uint32 CompileShader_RW(GPU_Renderer* renderer, GPU_ShaderEnum shader_type, SDL_RWops* shader_source)
842
+
{
843
+
GPU_Log(" %s (dummy)\n", __func__);
844
+
845
+
return 0;
846
+
}
847
+
848
+
static Uint32 CompileShader(GPU_Renderer* renderer, GPU_ShaderEnum shader_type, const char* shader_source)
849
+
{
850
+
GPU_Log(" %s (dummy)\n", __func__);
851
+
852
+
return 0;
853
+
}
854
+
855
+
static void FreeShader(GPU_Renderer* renderer, Uint32 shader_object)
856
+
{
857
+
GPU_Log(" %s (dummy)\n", __func__);
858
+
}
859
+
860
+
static void AttachShader(GPU_Renderer* renderer, Uint32 program_object, Uint32 shader_object)
861
+
{
862
+
GPU_Log(" %s (dummy)\n", __func__);
863
+
}
864
+
865
+
static void DetachShader(GPU_Renderer* renderer, Uint32 program_object, Uint32 shader_object)
866
+
{
867
+
GPU_Log(" %s (dummy)\n", __func__);
868
+
}
869
+
870
+
static Uint8 LinkShaderProgram(GPU_Renderer* renderer, Uint32 program_object)
871
+
{
872
+
GPU_Log(" %s (dummy)\n", __func__);
873
+
874
+
return 1;
875
+
}
876
+
877
+
static void ActivateShaderProgram(GPU_Renderer* renderer, Uint32 program_object, GPU_ShaderBlock* block)
878
+
{
879
+
GPU_Target* target = renderer->current_context_target;
880
+
881
+
GPU_Log(" %s (dummy)\n", __func__);
882
+
883
+
if(target == NULL)
884
+
return;
885
+
886
+
if((renderer->enabled_features & GPU_FEATURE_BASIC_SHADERS) == GPU_FEATURE_BASIC_SHADERS)
887
+
{
888
+
if(program_object == 0) // Implies default shader
889
+
{
890
+
// Already using a default shader?
891
+
if(target->context->current_shader_program == target->context->default_textured_shader_program
892
+
|| target->context->current_shader_program == target->context->default_untextured_shader_program)
893
+
return;
894
+
895
+
program_object = target->context->default_untextured_shader_program;
896
+
}
897
+
898
+
renderer->impl->FlushBlitBuffer(renderer);
899
+
}
900
+
901
+
target->context->current_shader_program = program_object;
902
+
}
903
+
904
+
905
+
static void DeactivateShaderProgram(GPU_Renderer* renderer)
906
+
{
907
+
GPU_Log(" %s (dummy)\n", __func__);
908
+
}
909
+
910
+
911
+
static const char* GetShaderMessage(GPU_Renderer* renderer)
912
+
{
913
+
GPU_Log(" %s (dummy)\n", __func__);
914
+
return "";
915
+
}
916
+
917
+
918
+
static int GetAttributeLocation(GPU_Renderer* renderer, Uint32 program_object, const char* attrib_name)
919
+
{
920
+
GPU_Log(" %s (dummy)\n", __func__);
921
+
return -1;
922
+
}
923
+
924
+
925
+
static int GetUniformLocation(GPU_Renderer* renderer, Uint32 program_object, const char* uniform_name)
926
+
{
927
+
GPU_Log(" %s (dummy)\n", __func__);
928
+
return -1;
929
+
}
930
+
931
+
932
+
static GPU_ShaderBlock LoadShaderBlock(GPU_Renderer* renderer, Uint32 program_object, const char* position_name, const char* texcoord_name, const char* color_name, const char* modelViewMatrix_name)
933
+
{
934
+
GPU_ShaderBlock b;
935
+
936
+
GPU_Log(" %s (dummy)\n", __func__);
937
+
938
+
b.position_loc = -1;
939
+
b.texcoord_loc = -1;
940
+
b.color_loc = -1;
941
+
b.modelViewProjection_loc = -1;
942
+
return b;
943
+
}
944
+
945
+
946
+
static void SetShaderBlock(GPU_Renderer* renderer, GPU_ShaderBlock block)
947
+
{
948
+
GPU_Log(" %s (dummy)\n", __func__);
949
+
}
950
+
951
+
952
+
static void SetShaderImage(GPU_Renderer* renderer, GPU_Image* image, int location, int image_unit)
953
+
{
954
+
GPU_Log(" %s (dummy)\n", __func__);
955
+
}
956
+
957
+
958
+
static void GetUniformiv(GPU_Renderer* renderer, Uint32 program_object, int location, int* values)
959
+
{
960
+
GPU_Log(" %s (dummy)\n", __func__);
961
+
}
962
+
963
+
964
+
static void SetUniformi(GPU_Renderer* renderer, int location, int value)
965
+
{
966
+
GPU_Log(" %s (dummy)\n", __func__);
967
+
}
968
+
969
+
970
+
static void SetUniformiv(GPU_Renderer* renderer, int location, int num_elements_per_value, int num_values, int* values)
971
+
{
972
+
GPU_Log(" %s (dummy)\n", __func__);
973
+
}
974
+
975
+
976
+
static void GetUniformuiv(GPU_Renderer* renderer, Uint32 program_object, int location, unsigned int* values)
977
+
{
978
+
GPU_Log(" %s (dummy)\n", __func__);
979
+
}
980
+
981
+
982
+
static void SetUniformui(GPU_Renderer* renderer, int location, unsigned int value)
983
+
{
984
+
GPU_Log(" %s (dummy)\n", __func__);
985
+
}
986
+
987
+
988
+
static void SetUniformuiv(GPU_Renderer* renderer, int location, int num_elements_per_value, int num_values, unsigned int* values)
989
+
{
990
+
GPU_Log(" %s (dummy)\n", __func__);
991
+
}
992
+
993
+
994
+
static void GetUniformfv(GPU_Renderer* renderer, Uint32 program_object, int location, float* values)
995
+
{
996
+
GPU_Log(" %s (dummy)\n", __func__);
997
+
}
998
+
999
+
1000
+
static void SetUniformf(GPU_Renderer* renderer, int location, float value)
1001
+
{
1002
+
GPU_Log(" %s (dummy)\n", __func__);
1003
+
}
1004
+
1005
+
1006
+
static void SetUniformfv(GPU_Renderer* renderer, int location, int num_elements_per_value, int num_values, float* values)
1007
+
{
1008
+
GPU_Log(" %s (dummy)\n", __func__);
1009
+
}
1010
+
1011
+
1012
+
static void SetUniformMatrixfv(GPU_Renderer* renderer, int location, int num_matrices, int num_rows, int num_columns, Uint8 transpose, float* values)
1013
+
{
1014
+
GPU_Log(" %s (dummy)\n", __func__);
1015
+
}
1016
+
1017
+
1018
+
static void SetAttributef(GPU_Renderer* renderer, int location, float value)
1019
+
{
1020
+
GPU_Log(" %s (dummy)\n", __func__);
1021
+
}
1022
+
1023
+
1024
+
static void SetAttributei(GPU_Renderer* renderer, int location, int value)
1025
+
{
1026
+
GPU_Log(" %s (dummy)\n", __func__);
1027
+
}
1028
+
1029
+
1030
+
static void SetAttributeui(GPU_Renderer* renderer, int location, unsigned int value)
1031
+
{
1032
+
GPU_Log(" %s (dummy)\n", __func__);
1033
+
}
1034
+
1035
+
1036
+
static void SetAttributefv(GPU_Renderer* renderer, int location, int num_elements, float* value)
1037
+
{
1038
+
GPU_Log(" %s (dummy)\n", __func__);
1039
+
}
1040
+
1041
+
1042
+
static void SetAttributeiv(GPU_Renderer* renderer, int location, int num_elements, int* value)
1043
+
{
1044
+
GPU_Log(" %s (dummy)\n", __func__);
1045
+
}
1046
+
1047
+
1048
+
static void SetAttributeuiv(GPU_Renderer* renderer, int location, int num_elements, unsigned int* value)
1049
+
{
1050
+
GPU_Log(" %s (dummy)\n", __func__);
1051
+
}
1052
+
1053
+
1054
+
static void SetAttributeSource(GPU_Renderer* renderer, int num_values, GPU_Attribute source)
1055
+
{
1056
+
GPU_Log(" %s (dummy)\n", __func__);
1057
+
}
1058
+
1059
+
1060
+
// Shapes
1061
+
1062
+
1063
+
static float SetLineThickness(GPU_Renderer* renderer, float thickness)
1064
+
{
1065
+
GPU_Log(" %s (dummy)\n", __func__);
1066
+
return 1.0f;
1067
+
}
1068
+
1069
+
1070
+
static float GetLineThickness(GPU_Renderer* renderer)
1071
+
{
1072
+
GPU_Log(" %s (dummy)\n", __func__);
1073
+
return 1.0f;
1074
+
}
1075
+
1076
+
1077
+
static void Pixel(GPU_Renderer* renderer, GPU_Target* target, float x, float y, SDL_Color color)
1078
+
{
1079
+
GPU_Log(" %s (dummy)\n", __func__);
1080
+
}
1081
+
1082
+
1083
+
static void Line(GPU_Renderer* renderer, GPU_Target* target, float x1, float y1, float x2, float y2, SDL_Color color)
1084
+
{
1085
+
GPU_Log(" %s (dummy)\n", __func__);
1086
+
}
1087
+
1088
+
1089
+
static void Arc(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, float start_angle, float end_angle, SDL_Color color)
1090
+
{
1091
+
GPU_Log(" %s (dummy)\n", __func__);
1092
+
}
1093
+
1094
+
1095
+
static void ArcFilled(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, float start_angle, float end_angle, SDL_Color color)
1096
+
{
1097
+
GPU_Log(" %s (dummy)\n", __func__);
1098
+
}
1099
+
1100
+
1101
+
static void Circle(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, SDL_Color color)
1102
+
{
1103
+
GPU_Log(" %s (dummy)\n", __func__);
1104
+
}
1105
+
1106
+
1107
+
static void CircleFilled(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, SDL_Color color)
1108
+
{
1109
+
GPU_Log(" %s (dummy)\n", __func__);
1110
+
}
1111
+
1112
+
1113
+
static void Ellipse(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float rx, float ry, float degrees, SDL_Color color)
1114
+
{
1115
+
GPU_Log(" %s (dummy)\n", __func__);
1116
+
}
1117
+
1118
+
1119
+
static void EllipseFilled(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float rx, float ry, float degrees, SDL_Color color)
1120
+
{
1121
+
GPU_Log(" %s (dummy)\n", __func__);
1122
+
}
1123
+
1124
+
1125
+
static void Sector(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float start_angle, float end_angle, SDL_Color color)
1126
+
{
1127
+
GPU_Log(" %s (dummy)\n", __func__);
1128
+
}
1129
+
1130
+
1131
+
static void SectorFilled(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float start_angle, float end_angle, SDL_Color color)
1132
+
{
1133
+
GPU_Log(" %s (dummy)\n", __func__);
1134
+
}
1135
+
1136
+
1137
+
static void Tri(GPU_Renderer* renderer, GPU_Target* target, float x1, float y1, float x2, float y2, float x3, float y3, SDL_Color color)
1138
+
{
1139
+
GPU_Log(" %s (dummy)\n", __func__);
1140
+
}
1141
+
1142
+
1143
+
static void TriFilled(GPU_Renderer* renderer, GPU_Target* target, float x1, float y1, float x2, float y2, float x3, float y3, SDL_Color color)
1144
+
{
1145
+
GPU_Log(" %s (dummy)\n", __func__);
1146
+
}
1147
+
1148
+
1149
+
static void Rectangle(GPU_Renderer* renderer, GPU_Target* target, float x1, float y1, float x2, float y2, SDL_Color color)
1150
+
{
1151
+
GPU_Log(" %s (dummy)\n", __func__);
1152
+
}
1153
+
1154
+
1155
+
static void RectangleFilled(GPU_Renderer* renderer, GPU_Target* target, float x1, float y1, float x2, float y2, SDL_Color color)
1156
+
{
1157
+
GPU_Log(" %s (dummy)\n", __func__);
1158
+
}
1159
+
1160
+
1161
+
static void RectangleRound(GPU_Renderer* renderer, GPU_Target* target, float x1, float y1, float x2, float y2, float radius, SDL_Color color)
1162
+
{
1163
+
GPU_Log(" %s (dummy)\n", __func__);
1164
+
}
1165
+
1166
+
1167
+
static void RectangleRoundFilled(GPU_Renderer* renderer, GPU_Target* target, float x1, float y1, float x2, float y2, float radius, SDL_Color color)
1168
+
{
1169
+
GPU_Log(" %s (dummy)\n", __func__);
1170
+
}
1171
+
1172
+
1173
+
static void Polygon(GPU_Renderer* renderer, GPU_Target* target, unsigned int num_vertices, float* vertices, SDL_Color color)
1174
+
{
1175
+
GPU_Log(" %s (dummy)\n", __func__);
1176
+
}
1177
+
1178
+
static void PolygonFilled(GPU_Renderer* renderer, GPU_Target* target, unsigned int num_vertices, float* vertices, SDL_Color color)
1179
+
{
1180
+
GPU_Log(" %s (dummy)\n", __func__);
1181
+
}
1182
+
1183
+
1184
+
1185
+
1186
+
void set_renderer_functions(GPU_RendererImpl* impl)
1187
+
{
1188
+
impl->Init = &Init;
1189
+
impl->CreateTargetFromWindow = &CreateTargetFromWindow;
1190
+
impl->CreateAliasTarget = &CreateAliasTarget;
1191
+
impl->MakeCurrent = &MakeCurrent;
1192
+
impl->SetAsCurrent = &SetAsCurrent;
1193
+
impl->ResetRendererState = &ResetRendererState;
1194
+
impl->SetWindowResolution = &SetWindowResolution;
1195
+
impl->SetVirtualResolution = &SetVirtualResolution;
1196
+
impl->UnsetVirtualResolution = &UnsetVirtualResolution;
1197
+
impl->Quit = &Quit;
1198
+
1199
+
impl->SetFullscreen = &SetFullscreen;
1200
+
impl->SetCamera = &SetCamera;
1201
+
1202
+
impl->CreateImage = &CreateImage;
1203
+
impl->CreateImageUsingTexture = &CreateImageUsingTexture;
1204
+
impl->LoadImage = &LoadImage;
1205
+
impl->CreateAliasImage = &CreateAliasImage;
1206
+
impl->SaveImage = &SaveImage;
1207
+
impl->CopyImage = &CopyImage;
1208
+
impl->UpdateImage = &UpdateImage;
1209
+
impl->UpdateSubImage = &UpdateSubImage;
1210
+
impl->UpdateImageBytes = &UpdateImageBytes;
1211
+
impl->CopyImageFromSurface = &CopyImageFromSurface;
1212
+
impl->CopyImageFromTarget = &CopyImageFromTarget;
1213
+
impl->CopySurfaceFromTarget = &CopySurfaceFromTarget;
1214
+
impl->CopySurfaceFromImage = &CopySurfaceFromImage;
1215
+
impl->FreeImage = &FreeImage;
1216
+
1217
+
impl->LoadTarget = &LoadTarget;
1218
+
impl->FreeTarget = &FreeTarget;
1219
+
1220
+
impl->Blit = &Blit;
1221
+
impl->BlitRotate = &BlitRotate;
1222
+
impl->BlitScale = &BlitScale;
1223
+
impl->BlitTransform = &BlitTransform;
1224
+
impl->BlitTransformX = &BlitTransformX;
1225
+
impl->BlitTransformMatrix = &BlitTransformMatrix;
1226
+
impl->BlitBatch = &BlitBatch;
1227
+
impl->TriangleBatch = &TriangleBatch;
1228
+
1229
+
impl->GenerateMipmaps = &GenerateMipmaps;
1230
+
1231
+
impl->SetClip = &SetClip;
1232
+
impl->UnsetClip = &UnsetClip;
1233
+
1234
+
impl->GetPixel = &GetPixel;
1235
+
impl->SetImageFilter = &SetImageFilter;
1236
+
impl->SetWrapMode = &SetWrapMode;
1237
+
1238
+
impl->ClearRGBA = &ClearRGBA;
1239
+
impl->FlushBlitBuffer = &FlushBlitBuffer;
1240
+
impl->Flip = &Flip;
1241
+
1242
+
impl->CreateShaderProgram = &CreateShaderProgram;
1243
+
impl->FreeShaderProgram = &FreeShaderProgram;
1244
+
impl->CompileShader_RW = &CompileShader_RW;
1245
+
impl->CompileShader = &CompileShader;
1246
+
impl->FreeShader = &FreeShader;
1247
+
impl->AttachShader = &AttachShader;
1248
+
impl->DetachShader = &DetachShader;
1249
+
impl->LinkShaderProgram = &LinkShaderProgram;
1250
+
impl->ActivateShaderProgram = &ActivateShaderProgram;
1251
+
impl->DeactivateShaderProgram = &DeactivateShaderProgram;
1252
+
impl->GetShaderMessage = &GetShaderMessage;
1253
+
impl->GetAttributeLocation = &GetAttributeLocation;
1254
+
impl->GetUniformLocation = &GetUniformLocation;
1255
+
impl->LoadShaderBlock = &LoadShaderBlock;
1256
+
impl->SetShaderBlock = &SetShaderBlock;
1257
+
impl->SetShaderImage = &SetShaderImage;
1258
+
impl->GetUniformiv = &GetUniformiv;
1259
+
impl->SetUniformi = &SetUniformi;
1260
+
impl->SetUniformiv = &SetUniformiv;
1261
+
impl->GetUniformuiv = &GetUniformuiv;
1262
+
impl->SetUniformui = &SetUniformui;
1263
+
impl->SetUniformuiv = &SetUniformuiv;
1264
+
impl->GetUniformfv = &GetUniformfv;
1265
+
impl->SetUniformf = &SetUniformf;
1266
+
impl->SetUniformfv = &SetUniformfv;
1267
+
impl->SetUniformMatrixfv = &SetUniformMatrixfv;
1268
+
impl->SetAttributef = &SetAttributef;
1269
+
impl->SetAttributei = &SetAttributei;
1270
+
impl->SetAttributeui = &SetAttributeui;
1271
+
impl->SetAttributefv = &SetAttributefv;
1272
+
impl->SetAttributeiv = &SetAttributeiv;
1273
+
impl->SetAttributeuiv = &SetAttributeuiv;
1274
+
impl->SetAttributeSource = &SetAttributeSource;
1275
+
1276
+
/* Shape rendering */
1277
+
1278
+
impl->SetLineThickness = &SetLineThickness;
1279
+
impl->GetLineThickness = &GetLineThickness;
1280
+
impl->Pixel = &Pixel;
1281
+
impl->Line = &Line;
1282
+
impl->Arc = &Arc;
1283
+
impl->ArcFilled = &ArcFilled;
1284
+
impl->Circle = &Circle;
1285
+
impl->CircleFilled = &CircleFilled;
1286
+
impl->Ellipse = &Ellipse;
1287
+
impl->EllipseFilled = &EllipseFilled;
1288
+
impl->Sector = &Sector;
1289
+
impl->SectorFilled = &SectorFilled;
1290
+
impl->Tri = &Tri;
1291
+
impl->TriFilled = &TriFilled;
1292
+
impl->Rectangle = &Rectangle;
1293
+
impl->RectangleFilled = &RectangleFilled;
1294
+
impl->RectangleRound = &RectangleRound;
1295
+
impl->RectangleRoundFilled = &RectangleRoundFilled;
1296
+
impl->Polygon = &Polygon;
1297
+
impl->PolygonFilled = &PolygonFilled;
1298
+
}
1299
+
1300
+
1301
+
GPU_Renderer* create_dummy_renderer(GPU_RendererID request)
1302
+
{
1303
+
GPU_Renderer* renderer = (GPU_Renderer*)malloc(sizeof(GPU_Renderer));
1304
+
if(renderer == NULL)
1305
+
return NULL;
1306
+
1307
+
memset(renderer, 0, sizeof(GPU_Renderer));
1308
+
1309
+
renderer->id = GPU_MakeRendererID(request.id, 1, 0);
1310
+
renderer->shader_language = GPU_LANGUAGE_NONE;
1311
+
renderer->shader_version = 0;
1312
+
1313
+
renderer->current_context_target = NULL;
1314
+
1315
+
renderer->impl = (GPU_RendererImpl*)malloc(sizeof(GPU_RendererImpl));
1316
+
memset(renderer->impl, 0, sizeof(GPU_RendererImpl));
1317
+
set_renderer_functions(renderer->impl);
1318
+
1319
+
return renderer;
1320
+
}
1321
+
1322
+
void free_dummy_renderer(GPU_Renderer* renderer)
1323
+
{
1324
+
if(renderer == NULL)
1325
+
return;
1326
+
1327
+
free(renderer);
1328
+
}
1329
+
1330
+
int main(int argc, char* argv[])
1331
+
{
1332
+
GPU_Target* screen;
1333
+
1334
+
// Prepare renderer for SDL_gpu to use
1335
+
GPU_RendererID rendererID = GPU_MakeRendererID(GPU_ReserveNextRendererEnum(), 1, 0);
1336
+
GPU_RegisterRenderer(rendererID, &create_dummy_renderer, &free_dummy_renderer);
1337
+
1338
+
printRenderers();
1339
+
1340
+
// Request this specific renderer
1341
+
screen = GPU_InitRenderer(rendererID.id, 800, 600, GPU_DEFAULT_INIT_FLAGS);
1342
+
if(screen == NULL)
1343
+
return -1;
1344
+
1345
+
printCurrentRenderer();
1346
+
1347
+
{
1348
+
Uint32 startTime;
1349
+
long frameCount;
1350
+
Uint8 done;
1351
+
SDL_Event event;
1352
+
1353
+
startTime = SDL_GetTicks();
1354
+
frameCount = 0;
1355
+
1356
+
done = 0;
1357
+
while(!done)
1358
+
{
1359
+
while(SDL_PollEvent(&event))
1360
+
{
1361
+
if(event.type == SDL_QUIT)
1362
+
done = 1;
1363
+
else if(event.type == SDL_KEYDOWN)
1364
+
{
1365
+
if(event.key.keysym.sym == SDLK_ESCAPE)
1366
+
done = 1;
1367
+
}
1368
+
}
1369
+
1370
+
GPU_Clear(screen);
1371
+
1372
+
GPU_Flip(screen);
1373
+
1374
+
frameCount++;
1375
+
if(frameCount%500 == 0)
1376
+
printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime));
1377
+
}
1378
+
1379
+
printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime));
1380
+
}
1381
+
1382
+
GPU_Quit();
1383
+
1384
+
return 0;
1385
+
}
1386
+
1387
+
#endif
+1
-1
demos/windows/main.c
+1
-1
demos/windows/main.c