SDL_gpu_renderer.c

Go to the documentation of this file.

#include "SDL_gpu.h"
#include "SDL_platform.h"
#include <string.h>

#ifndef _MSC_VER
    #include <strings.h>
#else
    #define __func__ __FUNCTION__
#endif

#define GPU_MAX_ACTIVE_RENDERERS 20
#define GPU_MAX_REGISTERED_RENDERERS 10

void gpu_init_renderer_register(void);
void gpu_free_renderer_register(void);

typedef struct GPU_RendererRegistration
{
    GPU_RendererID id;
    GPU_Renderer* (*createFn)(GPU_RendererID request);
    void (*freeFn)(GPU_Renderer*);
} GPU_RendererRegistration;

static GPU_bool _gpu_renderer_register_is_initialized = GPU_FALSE;

static GPU_Renderer* _gpu_renderer_map[GPU_MAX_ACTIVE_RENDERERS];
static GPU_RendererRegistration _gpu_renderer_register[GPU_MAX_REGISTERED_RENDERERS];

static int _gpu_renderer_order_size = 0;
static GPU_RendererID _gpu_renderer_order[GPU_RENDERER_ORDER_MAX];






GPU_RendererEnum GPU_ReserveNextRendererEnum(void)
{
    static GPU_RendererEnum last_enum = GPU_RENDERER_CUSTOM_0;
    return last_enum++;
}

int GPU_GetNumActiveRenderers(void)
{
    int count;
    int i;

    gpu_init_renderer_register();

    count = 0;
    for(i = 0; i < GPU_MAX_ACTIVE_RENDERERS; i++)
    {
        if(_gpu_renderer_map[i] != NULL)
            count++;
    }
    return count;
}

void GPU_GetActiveRendererList(GPU_RendererID* renderers_array)
{
    int count;
    int i;

    gpu_init_renderer_register();

    count = 0;
    for(i = 0; i < GPU_MAX_ACTIVE_RENDERERS; i++)
    {
        if(_gpu_renderer_map[i] != NULL)
        {
            renderers_array[count] = _gpu_renderer_map[i]->id;
            count++;
        }
    }
}


int GPU_GetNumRegisteredRenderers(void)
{
    int count;
    int i;

    gpu_init_renderer_register();

    count = 0;
    for(i = 0; i < GPU_MAX_REGISTERED_RENDERERS; i++)
    {
        if(_gpu_renderer_register[i].id.renderer != GPU_RENDERER_UNKNOWN)
            count++;
    }
    return count;
}

void GPU_GetRegisteredRendererList(GPU_RendererID* renderers_array)
{
    int count;
    int i;

    gpu_init_renderer_register();

    count = 0;
    for(i = 0; i < GPU_MAX_REGISTERED_RENDERERS; i++)
    {
        if(_gpu_renderer_register[i].id.renderer != GPU_RENDERER_UNKNOWN)
        {
            renderers_array[count] = _gpu_renderer_register[i].id;
            count++;
        }
    }
}


GPU_RendererID GPU_GetRendererID(GPU_RendererEnum renderer)
{
    int i;

    gpu_init_renderer_register();

    for(i = 0; i < GPU_MAX_REGISTERED_RENDERERS; i++)
    {
        if(_gpu_renderer_register[i].id.renderer == renderer)
            return _gpu_renderer_register[i].id;
    }
    
    return GPU_MakeRendererID("Unknown", GPU_RENDERER_UNKNOWN, 0, 0);
}

GPU_Renderer* GPU_CreateRenderer_OpenGL_1_BASE(GPU_RendererID request);
void GPU_FreeRenderer_OpenGL_1_BASE(GPU_Renderer* renderer);
GPU_Renderer* GPU_CreateRenderer_OpenGL_1(GPU_RendererID request);
void GPU_FreeRenderer_OpenGL_1(GPU_Renderer* renderer);
GPU_Renderer* GPU_CreateRenderer_OpenGL_2(GPU_RendererID request);
void GPU_FreeRenderer_OpenGL_2(GPU_Renderer* renderer);
GPU_Renderer* GPU_CreateRenderer_OpenGL_3(GPU_RendererID request);
void GPU_FreeRenderer_OpenGL_3(GPU_Renderer* renderer);
GPU_Renderer* GPU_CreateRenderer_OpenGL_4(GPU_RendererID request);
void GPU_FreeRenderer_OpenGL_4(GPU_Renderer* renderer);
GPU_Renderer* GPU_CreateRenderer_GLES_1(GPU_RendererID request);
void GPU_FreeRenderer_GLES_1(GPU_Renderer* renderer);
GPU_Renderer* GPU_CreateRenderer_GLES_2(GPU_RendererID request);
void GPU_FreeRenderer_GLES_2(GPU_Renderer* renderer);
GPU_Renderer* GPU_CreateRenderer_GLES_3(GPU_RendererID request);
void GPU_FreeRenderer_GLES_3(GPU_Renderer* renderer);

void GPU_RegisterRenderer(GPU_RendererID id, GPU_Renderer* (*create_renderer)(GPU_RendererID request), void (*free_renderer)(GPU_Renderer* renderer))
{
    int i = GPU_GetNumRegisteredRenderers();
    
    if(i >= GPU_MAX_REGISTERED_RENDERERS)
        return;
    
    if(id.renderer == GPU_RENDERER_UNKNOWN)
    {
        GPU_PushErrorCode(__func__, GPU_ERROR_USER_ERROR, "Invalid renderer ID");
        return;
    }
    if(create_renderer == NULL)
    {
        GPU_PushErrorCode(__func__, GPU_ERROR_USER_ERROR, "NULL renderer create callback");
        return;
    }
    if(free_renderer == NULL)
    {
        GPU_PushErrorCode(__func__, GPU_ERROR_USER_ERROR, "NULL renderer free callback");
        return;
    }
    
    _gpu_renderer_register[i].id = id;
    _gpu_renderer_register[i].createFn = create_renderer;
    _gpu_renderer_register[i].freeFn = free_renderer;
}

void gpu_register_built_in_renderers(void)
{
    #ifndef SDL_GPU_DISABLE_OPENGL
        #ifndef SDL_GPU_DISABLE_OPENGL_1_BASE
        GPU_RegisterRenderer(GPU_MakeRendererID("OpenGL 1 BASE", GPU_RENDERER_OPENGL_1_BASE, 1, 1),
                             &GPU_CreateRenderer_OpenGL_1_BASE,
                             &GPU_FreeRenderer_OpenGL_1_BASE);
        #endif
        
        #ifndef SDL_GPU_DISABLE_OPENGL_1
        GPU_RegisterRenderer(GPU_MakeRendererID("OpenGL 1", GPU_RENDERER_OPENGL_1, 1, 1),
                             &GPU_CreateRenderer_OpenGL_1,
                             &GPU_FreeRenderer_OpenGL_1);
        #endif
    
        #ifndef SDL_GPU_DISABLE_OPENGL_2
            GPU_RegisterRenderer(GPU_MakeRendererID("OpenGL 2", GPU_RENDERER_OPENGL_2, 2, 0),
                                 &GPU_CreateRenderer_OpenGL_2,
                                 &GPU_FreeRenderer_OpenGL_2);
        #endif
    
        #ifndef SDL_GPU_DISABLE_OPENGL_3
            #ifdef __MACOSX__
            // Depending on OS X version, it might only support core GL 3.3 or 3.2
            GPU_RegisterRenderer(GPU_MakeRendererID("OpenGL 3", GPU_RENDERER_OPENGL_3, 3, 2),
                                 &GPU_CreateRenderer_OpenGL_3,
                                 &GPU_FreeRenderer_OpenGL_3);
            #else
            GPU_RegisterRenderer(GPU_MakeRendererID("OpenGL 3", GPU_RENDERER_OPENGL_3, 3, 0),
                                 &GPU_CreateRenderer_OpenGL_3,
                                 &GPU_FreeRenderer_OpenGL_3);
            #endif
        #endif
    
        #ifndef SDL_GPU_DISABLE_OPENGL_4
            #ifdef __MACOSX__
            GPU_RegisterRenderer(GPU_MakeRendererID("OpenGL 4", GPU_RENDERER_OPENGL_4, 4, 1),
                                 &GPU_CreateRenderer_OpenGL_4,
                                 &GPU_FreeRenderer_OpenGL_4);
            #else
            GPU_RegisterRenderer(GPU_MakeRendererID("OpenGL 4", GPU_RENDERER_OPENGL_4, 4, 0),
                                 &GPU_CreateRenderer_OpenGL_4,
                                 &GPU_FreeRenderer_OpenGL_4);
            #endif
        #endif
    #endif
    
    #ifndef SDL_GPU_DISABLE_GLES
        #ifndef SDL_GPU_DISABLE_GLES_1
        GPU_RegisterRenderer(GPU_MakeRendererID("OpenGLES 1", GPU_RENDERER_GLES_1, 1, 1),
                             &GPU_CreateRenderer_GLES_1,
                             &GPU_FreeRenderer_GLES_1);
        #endif
        #ifndef SDL_GPU_DISABLE_GLES_2
        GPU_RegisterRenderer(GPU_MakeRendererID("OpenGLES 2", GPU_RENDERER_GLES_2, 2, 0),
                             &GPU_CreateRenderer_GLES_2,
                             &GPU_FreeRenderer_GLES_2);
        #endif
        #ifndef SDL_GPU_DISABLE_GLES_3
        GPU_RegisterRenderer(GPU_MakeRendererID("OpenGLES 3", GPU_RENDERER_GLES_3, 3, 0),
                             &GPU_CreateRenderer_GLES_3,
                             &GPU_FreeRenderer_GLES_3);
        #endif
    #endif
    
}

void gpu_init_renderer_register(void)
{
    int i;

    if(_gpu_renderer_register_is_initialized)
        return;
    
    for(i = 0; i < GPU_MAX_REGISTERED_RENDERERS; i++)
    {
        _gpu_renderer_register[i].id.name = "Unknown";
        _gpu_renderer_register[i].id.renderer = GPU_RENDERER_UNKNOWN;
        _gpu_renderer_register[i].createFn = NULL;
        _gpu_renderer_register[i].freeFn = NULL;
    }
    for(i = 0; i < GPU_MAX_ACTIVE_RENDERERS; i++)
    {
        _gpu_renderer_map[i] = NULL;
    }
    
    GPU_GetDefaultRendererOrder(&_gpu_renderer_order_size, _gpu_renderer_order);
    
    _gpu_renderer_register_is_initialized = 1;
    
    gpu_register_built_in_renderers();
}

void gpu_free_renderer_register(void)
{
    int i;

    for(i = 0; i < GPU_MAX_REGISTERED_RENDERERS; i++)
    {
        _gpu_renderer_register[i].id.name = "Unknown";
        _gpu_renderer_register[i].id.renderer = GPU_RENDERER_UNKNOWN;
        _gpu_renderer_register[i].createFn = NULL;
        _gpu_renderer_register[i].freeFn = NULL;
    }
    for(i = 0; i < GPU_MAX_ACTIVE_RENDERERS; i++)
    {
        _gpu_renderer_map[i] = NULL;
    }
    
    _gpu_renderer_register_is_initialized = 0;
    _gpu_renderer_order_size = 0;
}


void GPU_GetRendererOrder(int* order_size, GPU_RendererID* order)
{
    if(order_size != NULL)
        *order_size = _gpu_renderer_order_size;
    
    if(order != NULL && _gpu_renderer_order_size > 0)
        memcpy(order, _gpu_renderer_order, _gpu_renderer_order_size*sizeof(GPU_RendererID));
}

void GPU_SetRendererOrder(int order_size, GPU_RendererID* order)
{
    if(order == NULL)
    {
        // Restore the default order
        int count = 0;
        GPU_RendererID default_order[GPU_RENDERER_ORDER_MAX];
        GPU_GetDefaultRendererOrder(&count, default_order);
        GPU_SetRendererOrder(count, default_order);  // Call us again with the default order
        return;
    }
    
    if(order_size <= 0)
        return;
    
    if(order_size > GPU_RENDERER_ORDER_MAX)
    {
        GPU_PushErrorCode(__func__, GPU_ERROR_USER_ERROR, "Given order_size (%d) is greater than GPU_RENDERER_ORDER_MAX (%d)", order_size, GPU_RENDERER_ORDER_MAX);
        order_size = GPU_RENDERER_ORDER_MAX;
    }
    
    memcpy(_gpu_renderer_order, order, order_size*sizeof(GPU_RendererID));
    _gpu_renderer_order_size = order_size;
}



void GPU_GetDefaultRendererOrder(int* order_size, GPU_RendererID* order)
{
    int count = 0;
    GPU_RendererID default_order[GPU_RENDERER_ORDER_MAX];
    
    #ifndef SDL_GPU_DISABLE_GLES
        #ifndef SDL_GPU_DISABLE_GLES3
            default_order[count++] = GPU_MakeRendererID("OpenGLES 3", GPU_RENDERER_GLES_3, 3, 0);
        #endif
        #ifndef SDL_GPU_DISABLE_GLES2
            default_order[count++] = GPU_MakeRendererID("OpenGLES 2", GPU_RENDERER_GLES_2, 2, 0);
        #endif
        #ifndef SDL_GPU_DISABLE_GLES1
            default_order[count++] = GPU_MakeRendererID("OpenGLES 1", GPU_RENDERER_GLES_1, 1, 1);
        #endif
    #endif
    
    #ifndef SDL_GPU_DISABLE_OPENGL
        #ifdef __MACOSX__
        
            // My understanding of OS X OpenGL support:
            // OS X 10.9: GL 2.1, 3.3, 4.1
            // OS X 10.7: GL 2.1, 3.2
            // OS X 10.6: GL 1.4, 2.1
            #ifndef SDL_GPU_DISABLE_OPENGL_4
            default_order[count++] = GPU_MakeRendererID("OpenGL 4", GPU_RENDERER_OPENGL_4, 4, 1);
            #endif
            #ifndef SDL_GPU_DISABLE_OPENGL_3
            default_order[count++] = GPU_MakeRendererID("OpenGL 3", GPU_RENDERER_OPENGL_3, 3, 2);
            #endif
        
        #else
        
            #ifndef SDL_GPU_DISABLE_OPENGL_4
            default_order[count++] = GPU_MakeRendererID("OpenGL 4", GPU_RENDERER_OPENGL_4, 4, 0);
            #endif
            #ifndef SDL_GPU_DISABLE_OPENGL_3
            default_order[count++] = GPU_MakeRendererID("OpenGL 3", GPU_RENDERER_OPENGL_3, 3, 0);
            #endif
            
        #endif
        
        #ifndef SDL_GPU_DISABLE_OPENGL_2
        default_order[count++] = GPU_MakeRendererID("OpenGL 2", GPU_RENDERER_OPENGL_2, 2, 0);
        #endif
        #ifndef SDL_GPU_DISABLE_OPENGL_1
        default_order[count++] = GPU_MakeRendererID("OpenGL 1", GPU_RENDERER_OPENGL_1, 1, 1);
        #endif
        
    #endif
    
    if(order_size != NULL)
        *order_size = count;
    
    if(order != NULL && count > 0)
        memcpy(order, default_order, count*sizeof(GPU_RendererID));
}


GPU_Renderer* GPU_CreateRenderer(GPU_RendererID id)
{
    GPU_Renderer* result = NULL;
    int i;
    for(i = 0; i < GPU_MAX_REGISTERED_RENDERERS; i++)
    {
        if(_gpu_renderer_register[i].id.renderer == GPU_RENDERER_UNKNOWN)
            continue;
        
        if(id.renderer == _gpu_renderer_register[i].id.renderer)
        {
            if(_gpu_renderer_register[i].createFn != NULL)
            {
                // Use the registered name
                id.name = _gpu_renderer_register[i].id.name;
                result = _gpu_renderer_register[i].createFn(id);
            }
            break;
        }
    }
    
    if(result == NULL)
    {
        GPU_PushErrorCode(__func__, GPU_ERROR_DATA_ERROR, "Renderer was not found in the renderer registry.");
    }
    return result;
}

// Get a renderer from the map.
GPU_Renderer* GPU_GetRenderer(GPU_RendererID id)
{
    int i;
    gpu_init_renderer_register();
    
    // Invalid enum?
    if(id.renderer == GPU_RENDERER_UNKNOWN)
        return NULL;
    
    for(i = 0; i < GPU_MAX_ACTIVE_RENDERERS; i++)
    {
        if(_gpu_renderer_map[i] == NULL)
            continue;
        
        if(id.renderer == _gpu_renderer_map[i]->id.renderer)
            return _gpu_renderer_map[i];
    }
    
    return NULL;
}

// Create a new renderer based on a registered id and store it in the map.
GPU_Renderer* gpu_create_and_add_renderer(GPU_RendererID id)
{
    int i;
    for(i = 0; i < GPU_MAX_ACTIVE_RENDERERS; i++)
    {
        if(_gpu_renderer_map[i] == NULL)
        {
            // Create
            GPU_Renderer* renderer = GPU_CreateRenderer(id);
            if(renderer == NULL)
            {
                GPU_PushErrorCode(__func__, GPU_ERROR_BACKEND_ERROR, "Failed to create new renderer.");
                return NULL;
            }
            
            // Add
            _gpu_renderer_map[i] = renderer;
            // Return
            return renderer;
        }
    }
    
    GPU_PushErrorCode(__func__, GPU_ERROR_BACKEND_ERROR, "Couldn't create a new renderer.  Too many active renderers for GPU_MAX_ACTIVE_RENDERERS (%d).", GPU_MAX_ACTIVE_RENDERERS);
    return NULL;
}

// Free renderer memory according to how the registry instructs
void gpu_free_renderer_memory(GPU_Renderer* renderer)
{
    int i;
    if(renderer == NULL)
        return;
    
    for(i = 0; i < GPU_MAX_REGISTERED_RENDERERS; i++)
    {
        if(_gpu_renderer_register[i].id.renderer == GPU_RENDERER_UNKNOWN)
            continue;
        
        if(renderer->id.renderer == _gpu_renderer_register[i].id.renderer)
        {
            _gpu_renderer_register[i].freeFn(renderer);
            return;
        }
    }
}

// Remove a renderer from the active map and free it.
void GPU_FreeRenderer(GPU_Renderer* renderer)
{
    int i;
    GPU_Renderer* current_renderer;
    
    if(renderer == NULL)
        return;
    
    current_renderer = GPU_GetCurrentRenderer();
    if(current_renderer == renderer)
        GPU_SetCurrentRenderer(GPU_MakeRendererID("Unknown", GPU_RENDERER_UNKNOWN, 0, 0));
        
    for(i = 0; i < GPU_MAX_ACTIVE_RENDERERS; i++)
    {
        if(renderer == _gpu_renderer_map[i])
        {
            gpu_free_renderer_memory(renderer);
            _gpu_renderer_map[i] = NULL;
            return;
        }
    }
}