SDL_gpu.h

#ifndef _SDL_GPU_H__
#define _SDL_GPU_H__

#include "SDL.h"
#include <stdio.h>
#include <stdarg.h>

// Use SDL's DLL defines
#include "begin_code.h"

#ifdef __cplusplus
extern "C" {
#endif

// Compile-time versions
#define SDL_GPU_VERSION_MAJOR 0
#define SDL_GPU_VERSION_MINOR 11
#define SDL_GPU_VERSION_PATCH 0

/* Auto-detect if we're using the SDL2 API by the headers available. */
#if SDL_VERSION_ATLEAST(2,0,0)
    #define SDL_GPU_USE_SDL2
#else
    #define SDL_GPU_USE_SDL1
#endif


// Check for bool support
#ifdef __STDC_VERSION__
    #define GPU_HAVE_STDC 1
#else
    #define GPU_HAVE_STDC 0
#endif

#define GPU_HAVE_C99 (GPU_HAVE_STDC && (__STDC_VERSION__ >= 199901L))

#ifdef __GNUC__ // catches both gcc and clang I believe
    #define GPU_HAVE_GNUC 1
#else
    #define GPU_HAVE_GNUC 0
#endif

#ifdef _MSC_VER
    #define GPU_HAVE_MSVC 1
#else
    #define GPU_HAVE_MSVC 0
#endif

#define GPU_HAVE_MSVC18 (GPU_HAVE_MSVC && (_MSC_VER >= 1800)) // VS2013+

#if defined(GPU_USE_REAL_BOOL) && GPU_USE_REAL_BOOL  // allow user to specify
    #define GPU_bool bool
#elif defined(GPU_USE_INT_BOOL) && GPU_USE_INT_BOOL
    #define GPU_bool int
#elif GPU_HAVE_C99 || GPU_HAVE_GNUC || GPU_HAVE_MSVC18 || (defined(GPU_HAVE_STDBOOL) && GPU_HAVE_STDBOOL)
    #include <stdbool.h>
    #define GPU_bool bool
#else
    #define GPU_bool int
#endif

#define GPU_FALSE 0
#define GPU_TRUE 1


typedef struct GPU_Renderer GPU_Renderer;
typedef struct GPU_Target GPU_Target;

typedef struct GPU_Rect
{
    float x, y;
    float w, h;
} GPU_Rect;

#define GPU_RENDERER_ORDER_MAX 10

typedef Uint32 GPU_RendererEnum;
static const GPU_RendererEnum GPU_RENDERER_UNKNOWN = 0;  // invalid value
static const GPU_RendererEnum GPU_RENDERER_OPENGL_1_BASE = 1;
static const GPU_RendererEnum GPU_RENDERER_OPENGL_1 = 2;
static const GPU_RendererEnum GPU_RENDERER_OPENGL_2 = 3;
static const GPU_RendererEnum GPU_RENDERER_OPENGL_3 = 4;
static const GPU_RendererEnum GPU_RENDERER_OPENGL_4 = 5;
static const GPU_RendererEnum GPU_RENDERER_GLES_1 = 11;
static const GPU_RendererEnum GPU_RENDERER_GLES_2 = 12;
static const GPU_RendererEnum GPU_RENDERER_GLES_3 = 13;
static const GPU_RendererEnum GPU_RENDERER_D3D9 = 21;
static const GPU_RendererEnum GPU_RENDERER_D3D10 = 22;
static const GPU_RendererEnum GPU_RENDERER_D3D11 = 23;
#define GPU_RENDERER_CUSTOM_0 1000

typedef struct GPU_RendererID
{
    const char* name;
    GPU_RendererEnum renderer;
    int major_version;
    int minor_version;
} GPU_RendererID;


typedef enum {
    GPU_FUNC_ZERO = 0,
    GPU_FUNC_ONE = 1,
    GPU_FUNC_SRC_COLOR = 0x0300,
    GPU_FUNC_DST_COLOR = 0x0306,
    GPU_FUNC_ONE_MINUS_SRC = 0x0301,
    GPU_FUNC_ONE_MINUS_DST = 0x0307,
    GPU_FUNC_SRC_ALPHA = 0x0302,
    GPU_FUNC_DST_ALPHA = 0x0304,
    GPU_FUNC_ONE_MINUS_SRC_ALPHA = 0x0303,
    GPU_FUNC_ONE_MINUS_DST_ALPHA = 0x0305
} GPU_BlendFuncEnum;

typedef enum {
    GPU_EQ_ADD = 0x8006,
    GPU_EQ_SUBTRACT = 0x800A,
    GPU_EQ_REVERSE_SUBTRACT = 0x800B
} GPU_BlendEqEnum;

typedef struct GPU_BlendMode
{
    GPU_BlendFuncEnum source_color;
    GPU_BlendFuncEnum dest_color;
    GPU_BlendFuncEnum source_alpha;
    GPU_BlendFuncEnum dest_alpha;
    
    GPU_BlendEqEnum color_equation;
    GPU_BlendEqEnum alpha_equation;
} GPU_BlendMode;

typedef enum {
    GPU_BLEND_NORMAL = 0,
    GPU_BLEND_PREMULTIPLIED_ALPHA = 1,
    GPU_BLEND_MULTIPLY = 2,
    GPU_BLEND_ADD = 3,
    GPU_BLEND_SUBTRACT = 4,
    GPU_BLEND_MOD_ALPHA = 5,
    GPU_BLEND_SET_ALPHA = 6,
    GPU_BLEND_SET = 7,
    GPU_BLEND_NORMAL_KEEP_ALPHA = 8,
    GPU_BLEND_NORMAL_ADD_ALPHA = 9,
    GPU_BLEND_NORMAL_FACTOR_ALPHA = 10
} GPU_BlendPresetEnum;

typedef enum {
    GPU_FILTER_NEAREST = 0,
    GPU_FILTER_LINEAR = 1,
    GPU_FILTER_LINEAR_MIPMAP = 2
} GPU_FilterEnum;

typedef enum {
    GPU_SNAP_NONE = 0,
    GPU_SNAP_POSITION = 1,
    GPU_SNAP_DIMENSIONS = 2,
    GPU_SNAP_POSITION_AND_DIMENSIONS = 3
} GPU_SnapEnum;


typedef enum {
    GPU_WRAP_NONE = 0,
    GPU_WRAP_REPEAT = 1,
    GPU_WRAP_MIRRORED = 2
} GPU_WrapEnum;

typedef enum {
    GPU_FORMAT_LUMINANCE = 1,
    GPU_FORMAT_LUMINANCE_ALPHA = 2,
    GPU_FORMAT_RGB = 3,
    GPU_FORMAT_RGBA = 4,
    GPU_FORMAT_ALPHA = 5,
    GPU_FORMAT_RG = 6,
    GPU_FORMAT_YCbCr422 = 7,
    GPU_FORMAT_YCbCr420P = 8
} GPU_FormatEnum;

typedef enum {
    GPU_FILE_AUTO = 0,
    GPU_FILE_PNG,
    GPU_FILE_BMP,
    GPU_FILE_TGA
} GPU_FileFormatEnum;



typedef struct GPU_Image
{
    struct GPU_Renderer* renderer;
    GPU_Target* context_target;
    GPU_Target* target;
    Uint16 w, h;
    GPU_bool using_virtual_resolution;
    GPU_FormatEnum format;
    int num_layers;
    int bytes_per_pixel;
    Uint16 base_w, base_h;  // Original image dimensions
    Uint16 texture_w, texture_h;  // Underlying texture dimensions
    GPU_bool has_mipmaps;
    
    float anchor_x; // Normalized coords for the point at which the image is blitted.  Default is (0.5, 0.5), that is, the image is drawn centered.
    float anchor_y; // These are interpreted according to GPU_SetCoordinateMode() and range from (0.0 - 1.0) normally.
    
    SDL_Color color;
    GPU_bool use_blending;
    GPU_BlendMode blend_mode;
    GPU_FilterEnum filter_mode;
    GPU_SnapEnum snap_mode;
    GPU_WrapEnum wrap_mode_x;
    GPU_WrapEnum wrap_mode_y;
    
    void* data;
    int refcount;
    GPU_bool is_alias;
} GPU_Image;


typedef struct GPU_Camera
{
    float x, y, z;
    float angle;
    float zoom;
} GPU_Camera;


typedef struct GPU_ShaderBlock
{
    // Attributes
    int position_loc;
    int texcoord_loc;
    int color_loc;
    // Uniforms
    int modelViewProjection_loc;
} GPU_ShaderBlock;





#define GPU_MODELVIEW 0
#define GPU_PROJECTION 1

#ifndef GPU_MATRIX_STACK_MAX
#define GPU_MATRIX_STACK_MAX 5
#endif

typedef struct GPU_MatrixStack
{
    unsigned int size;
    float matrix[GPU_MATRIX_STACK_MAX][16];
} GPU_MatrixStack;


typedef struct GPU_Context
{
    void* context;
    GPU_bool failed;
    
    Uint32 windowID;
    
    int window_w;
    int window_h;
    
    int drawable_w;
    int drawable_h;
    
    int stored_window_w;
    int stored_window_h;
    
    Uint32 current_shader_program;
    Uint32 default_textured_shader_program;
    Uint32 default_untextured_shader_program;
    
    GPU_ShaderBlock current_shader_block;
    GPU_ShaderBlock default_textured_shader_block;
    GPU_ShaderBlock default_untextured_shader_block;
    
    GPU_bool shapes_use_blending;
    GPU_BlendMode shapes_blend_mode;
    float line_thickness;
    GPU_bool use_texturing;
    
    int matrix_mode;
    GPU_MatrixStack projection_matrix;
    GPU_MatrixStack modelview_matrix;
    
    void* data;
} GPU_Context;


struct GPU_Target
{
    struct GPU_Renderer* renderer;
    GPU_Target* context_target;
    GPU_Image* image;
    void* data;
    Uint16 w, h;
    GPU_bool using_virtual_resolution;
    Uint16 base_w, base_h;  // The true dimensions of the underlying image or window
    GPU_bool use_clip_rect;
    GPU_Rect clip_rect;
    GPU_bool use_color;
    SDL_Color color;
    
    GPU_Rect viewport;
    
    GPU_Camera camera;
    GPU_bool use_camera;
    
    GPU_Context* context;
    int refcount;
    GPU_bool is_alias;
};

typedef Uint32 GPU_FeatureEnum;
static const GPU_FeatureEnum GPU_FEATURE_NON_POWER_OF_TWO = 0x1;
static const GPU_FeatureEnum GPU_FEATURE_RENDER_TARGETS = 0x2;
static const GPU_FeatureEnum GPU_FEATURE_BLEND_EQUATIONS = 0x4;
static const GPU_FeatureEnum GPU_FEATURE_BLEND_FUNC_SEPARATE = 0x8;
static const GPU_FeatureEnum GPU_FEATURE_BLEND_EQUATIONS_SEPARATE = 0x10;
static const GPU_FeatureEnum GPU_FEATURE_GL_BGR = 0x20;
static const GPU_FeatureEnum GPU_FEATURE_GL_BGRA = 0x40;
static const GPU_FeatureEnum GPU_FEATURE_GL_ABGR = 0x80;
static const GPU_FeatureEnum GPU_FEATURE_VERTEX_SHADER = 0x100;
static const GPU_FeatureEnum GPU_FEATURE_FRAGMENT_SHADER = 0x200;
static const GPU_FeatureEnum GPU_FEATURE_PIXEL_SHADER = 0x200;
static const GPU_FeatureEnum GPU_FEATURE_GEOMETRY_SHADER = 0x400;
static const GPU_FeatureEnum GPU_FEATURE_WRAP_REPEAT_MIRRORED = 0x800;

#define GPU_FEATURE_ALL_BASE GPU_FEATURE_RENDER_TARGETS
#define GPU_FEATURE_ALL_BLEND_PRESETS (GPU_FEATURE_BLEND_EQUATIONS | GPU_FEATURE_BLEND_FUNC_SEPARATE)
#define GPU_FEATURE_ALL_GL_FORMATS (GPU_FEATURE_GL_BGR | GPU_FEATURE_GL_BGRA | GPU_FEATURE_GL_ABGR)
#define GPU_FEATURE_BASIC_SHADERS (GPU_FEATURE_FRAGMENT_SHADER | GPU_FEATURE_VERTEX_SHADER)
#define GPU_FEATURE_ALL_SHADERS (GPU_FEATURE_FRAGMENT_SHADER | GPU_FEATURE_VERTEX_SHADER | GPU_FEATURE_GEOMETRY_SHADER)


typedef Uint32 GPU_WindowFlagEnum;

typedef Uint32 GPU_InitFlagEnum;
static const GPU_InitFlagEnum GPU_INIT_ENABLE_VSYNC = 0x1;
static const GPU_InitFlagEnum GPU_INIT_DISABLE_VSYNC = 0x2;
static const GPU_InitFlagEnum GPU_INIT_DISABLE_DOUBLE_BUFFER = 0x4;
static const GPU_InitFlagEnum GPU_INIT_DISABLE_AUTO_VIRTUAL_RESOLUTION = 0x8;
static const GPU_InitFlagEnum GPU_INIT_REQUEST_COMPATIBILITY_PROFILE = 0x10;

#define GPU_DEFAULT_INIT_FLAGS 0


static const Uint32 GPU_NONE = 0x0;

typedef Uint32 GPU_BatchFlagEnum;
static const GPU_BatchFlagEnum GPU_BATCH_XY = 0x1;
static const GPU_BatchFlagEnum GPU_BATCH_XYZ = 0x2;
static const GPU_BatchFlagEnum GPU_BATCH_ST = 0x4;
static const GPU_BatchFlagEnum GPU_BATCH_RGB = 0x8;
static const GPU_BatchFlagEnum GPU_BATCH_RGBA = 0x10;
static const GPU_BatchFlagEnum GPU_BATCH_RGB8 = 0x20;
static const GPU_BatchFlagEnum GPU_BATCH_RGBA8 = 0x40;

#define GPU_BATCH_XY_ST (GPU_BATCH_XY | GPU_BATCH_ST)
#define GPU_BATCH_XYZ_ST (GPU_BATCH_XYZ | GPU_BATCH_ST)
#define GPU_BATCH_XY_RGB (GPU_BATCH_XY | GPU_BATCH_RGB)
#define GPU_BATCH_XYZ_RGB (GPU_BATCH_XYZ | GPU_BATCH_RGB)
#define GPU_BATCH_XY_RGBA (GPU_BATCH_XY | GPU_BATCH_RGBA)
#define GPU_BATCH_XYZ_RGBA (GPU_BATCH_XYZ | GPU_BATCH_RGBA)
#define GPU_BATCH_XY_ST_RGBA (GPU_BATCH_XY | GPU_BATCH_ST | GPU_BATCH_RGBA)
#define GPU_BATCH_XYZ_ST_RGBA (GPU_BATCH_XYZ | GPU_BATCH_ST | GPU_BATCH_RGBA)
#define GPU_BATCH_XY_RGB8 (GPU_BATCH_XY | GPU_BATCH_RGB8)
#define GPU_BATCH_XYZ_RGB8 (GPU_BATCH_XYZ | GPU_BATCH_RGB8)
#define GPU_BATCH_XY_RGBA8 (GPU_BATCH_XY | GPU_BATCH_RGBA8)
#define GPU_BATCH_XYZ_RGBA8 (GPU_BATCH_XYZ | GPU_BATCH_RGBA8)
#define GPU_BATCH_XY_ST_RGBA8 (GPU_BATCH_XY | GPU_BATCH_ST | GPU_BATCH_RGBA8)
#define GPU_BATCH_XYZ_ST_RGBA8 (GPU_BATCH_XYZ | GPU_BATCH_ST | GPU_BATCH_RGBA8)


typedef Uint32 GPU_FlipEnum;
static const GPU_FlipEnum GPU_FLIP_NONE = 0x0;
static const GPU_FlipEnum GPU_FLIP_HORIZONTAL = 0x1;
static const GPU_FlipEnum GPU_FLIP_VERTICAL = 0x2;


typedef Uint32 GPU_TypeEnum;
// Use OpenGL's values for simpler translation
static const GPU_TypeEnum GPU_TYPE_BYTE = 0x1400;
static const GPU_TypeEnum GPU_TYPE_UNSIGNED_BYTE = 0x1401;
static const GPU_TypeEnum GPU_TYPE_SHORT = 0x1402;
static const GPU_TypeEnum GPU_TYPE_UNSIGNED_SHORT = 0x1403;
static const GPU_TypeEnum GPU_TYPE_INT = 0x1404;
static const GPU_TypeEnum GPU_TYPE_UNSIGNED_INT = 0x1405;
static const GPU_TypeEnum GPU_TYPE_FLOAT = 0x1406;
static const GPU_TypeEnum GPU_TYPE_DOUBLE = 0x140A;






typedef enum {
    GPU_VERTEX_SHADER = 0,
    GPU_FRAGMENT_SHADER = 1,
    GPU_PIXEL_SHADER = 1,
    GPU_GEOMETRY_SHADER = 2
} GPU_ShaderEnum;



typedef enum {
    GPU_LANGUAGE_NONE = 0,
    GPU_LANGUAGE_ARB_ASSEMBLY = 1,
    GPU_LANGUAGE_GLSL = 2,
    GPU_LANGUAGE_GLSLES = 3,
    GPU_LANGUAGE_HLSL = 4,
    GPU_LANGUAGE_CG = 5
} GPU_ShaderLanguageEnum;

typedef struct GPU_AttributeFormat
{
    GPU_bool is_per_sprite;  // Per-sprite values are expanded to 4 vertices
    int num_elems_per_value;
    GPU_TypeEnum type;  // GPU_TYPE_FLOAT, GPU_TYPE_INT, GPU_TYPE_UNSIGNED_INT, etc.
    GPU_bool normalize;
    int stride_bytes;  // Number of bytes between two vertex specifications
    int offset_bytes;  // Number of bytes to skip at the beginning of 'values'
} GPU_AttributeFormat;

typedef struct GPU_Attribute
{
    int location;
    void* values;  // Expect 4 values for each sprite
    GPU_AttributeFormat format;
} GPU_Attribute;

typedef struct GPU_AttributeSource
{
    GPU_bool enabled;
    int num_values;
    void* next_value;
    // Automatic storage format
    int per_vertex_storage_stride_bytes;
    int per_vertex_storage_offset_bytes;
    int per_vertex_storage_size;  // Over 0 means that the per-vertex storage has been automatically allocated
    void* per_vertex_storage;  // Could point to the attribute's values or to allocated storage
    GPU_Attribute attribute;
} GPU_AttributeSource;


typedef enum {
    GPU_ERROR_NONE = 0,
    GPU_ERROR_BACKEND_ERROR = 1,
    GPU_ERROR_DATA_ERROR = 2,
    GPU_ERROR_USER_ERROR = 3,
    GPU_ERROR_UNSUPPORTED_FUNCTION = 4,
    GPU_ERROR_NULL_ARGUMENT = 5,
    GPU_ERROR_FILE_NOT_FOUND = 6
} GPU_ErrorEnum;

typedef struct GPU_ErrorObject
{
    char* function;
    GPU_ErrorEnum error;
    char* details;
} GPU_ErrorObject;


typedef enum {
    GPU_DEBUG_LEVEL_0 = 0,
    GPU_DEBUG_LEVEL_1 = 1,
    GPU_DEBUG_LEVEL_2 = 2,
    GPU_DEBUG_LEVEL_3 = 3,
    GPU_DEBUG_LEVEL_MAX = 3
} GPU_DebugLevelEnum;


typedef enum {
    GPU_LOG_INFO = 0,
    GPU_LOG_WARNING,
    GPU_LOG_ERROR
} GPU_LogLevelEnum;


/* Private implementation of renderer members */
struct GPU_RendererImpl;

struct GPU_Renderer
{
    GPU_RendererID id;
    GPU_RendererID requested_id;
    GPU_WindowFlagEnum SDL_init_flags;
    GPU_InitFlagEnum GPU_init_flags;
    
    GPU_ShaderLanguageEnum shader_language;
    int min_shader_version;
    int max_shader_version;
    GPU_FeatureEnum enabled_features;
    
    GPU_Target* current_context_target;
    
    GPU_bool coordinate_mode;
    
    float default_image_anchor_x;
    float default_image_anchor_y;
    
    struct GPU_RendererImpl* impl;
};






// Visual C does not support static inline
#ifdef _MSC_VER
static SDL_version SDLCALL GPU_GetCompiledVersion(void)
#else
static inline SDL_version SDLCALL GPU_GetCompiledVersion(void)
#endif
{
    SDL_version v = {SDL_GPU_VERSION_MAJOR, SDL_GPU_VERSION_MINOR, SDL_GPU_VERSION_PATCH};
    return v;
}

DECLSPEC SDL_version SDLCALL GPU_GetLinkedVersion(void);

DECLSPEC void SDLCALL GPU_SetInitWindow(Uint32 windowID);

DECLSPEC Uint32 SDLCALL GPU_GetInitWindow(void);

DECLSPEC void SDLCALL GPU_SetPreInitFlags(GPU_InitFlagEnum GPU_flags);

DECLSPEC GPU_InitFlagEnum SDLCALL GPU_GetPreInitFlags(void);

DECLSPEC void SDLCALL GPU_SetRequiredFeatures(GPU_FeatureEnum features);

DECLSPEC GPU_FeatureEnum SDLCALL GPU_GetRequiredFeatures(void);

DECLSPEC void SDLCALL GPU_GetDefaultRendererOrder(int* order_size, GPU_RendererID* order);

DECLSPEC void SDLCALL GPU_GetRendererOrder(int* order_size, GPU_RendererID* order);

DECLSPEC void SDLCALL GPU_SetRendererOrder(int order_size, GPU_RendererID* order);

DECLSPEC GPU_Target* SDLCALL GPU_Init(Uint16 w, Uint16 h, GPU_WindowFlagEnum SDL_flags);

DECLSPEC GPU_Target* SDLCALL GPU_InitRenderer(GPU_RendererEnum renderer_enum, Uint16 w, Uint16 h, GPU_WindowFlagEnum SDL_flags);

DECLSPEC GPU_Target* SDLCALL GPU_InitRendererByID(GPU_RendererID renderer_request, Uint16 w, Uint16 h, GPU_WindowFlagEnum SDL_flags);

DECLSPEC GPU_bool SDLCALL GPU_IsFeatureEnabled(GPU_FeatureEnum feature);

DECLSPEC void SDLCALL GPU_CloseCurrentRenderer(void);

DECLSPEC void SDLCALL GPU_Quit(void);

// End of Initialization
// Debugging, logging, and error handling

#define GPU_Log GPU_LogInfo

DECLSPEC void SDLCALL GPU_SetDebugLevel(GPU_DebugLevelEnum level);

DECLSPEC GPU_DebugLevelEnum SDLCALL GPU_GetDebugLevel(void);

DECLSPEC void SDLCALL GPU_LogInfo(const char* format, ...);

DECLSPEC void SDLCALL GPU_LogWarning(const char* format, ...);

DECLSPEC void SDLCALL GPU_LogError(const char* format, ...);

DECLSPEC void SDLCALL GPU_SetLogCallback(int (*callback)(GPU_LogLevelEnum log_level, const char* format, va_list args));

DECLSPEC void SDLCALL GPU_PushErrorCode(const char* function, GPU_ErrorEnum error, const char* details, ...);

DECLSPEC GPU_ErrorObject SDLCALL GPU_PopErrorCode(void);

DECLSPEC const char* SDLCALL GPU_GetErrorString(GPU_ErrorEnum error);

DECLSPEC void SDLCALL GPU_SetErrorQueueMax(unsigned int max);

// End of Logging
DECLSPEC GPU_RendererID SDLCALL GPU_MakeRendererID(const char* name, GPU_RendererEnum renderer, int major_version, int minor_version);

DECLSPEC GPU_RendererID SDLCALL GPU_GetRendererID(GPU_RendererEnum renderer);

DECLSPEC int SDLCALL GPU_GetNumRegisteredRenderers(void);

DECLSPEC void SDLCALL GPU_GetRegisteredRendererList(GPU_RendererID* renderers_array);

DECLSPEC void SDLCALL GPU_RegisterRenderer(GPU_RendererID id, GPU_Renderer* (SDLCALL *create_renderer)(GPU_RendererID request), void (SDLCALL *free_renderer)(GPU_Renderer* renderer));

// End of RendererSetup
DECLSPEC GPU_RendererEnum SDLCALL GPU_ReserveNextRendererEnum(void);

DECLSPEC int SDLCALL GPU_GetNumActiveRenderers(void);

DECLSPEC void SDLCALL GPU_GetActiveRendererList(GPU_RendererID* renderers_array);

DECLSPEC GPU_Renderer* SDLCALL GPU_GetCurrentRenderer(void);

DECLSPEC void SDLCALL GPU_SetCurrentRenderer(GPU_RendererID id);

DECLSPEC GPU_Renderer* SDLCALL GPU_GetRenderer(GPU_RendererID id);

DECLSPEC void SDLCALL GPU_FreeRenderer(GPU_Renderer* renderer);

DECLSPEC void SDLCALL GPU_ResetRendererState(void);

DECLSPEC void SDLCALL GPU_SetCoordinateMode(GPU_bool use_math_coords);

DECLSPEC GPU_bool SDLCALL GPU_GetCoordinateMode(void);

DECLSPEC void SDLCALL GPU_SetDefaultAnchor(float anchor_x, float anchor_y);

DECLSPEC void SDLCALL GPU_GetDefaultAnchor(float* anchor_x, float* anchor_y);

// End of RendererControls
// Context / window controls

DECLSPEC GPU_Target* SDLCALL GPU_GetContextTarget(void);

DECLSPEC GPU_Target* SDLCALL GPU_GetWindowTarget(Uint32 windowID);

DECLSPEC GPU_Target* SDLCALL GPU_CreateTargetFromWindow(Uint32 windowID);

DECLSPEC void SDLCALL GPU_MakeCurrent(GPU_Target* target, Uint32 windowID);

DECLSPEC GPU_bool SDLCALL GPU_SetWindowResolution(Uint16 w, Uint16 h);

DECLSPEC GPU_bool SDLCALL GPU_SetFullscreen(GPU_bool enable_fullscreen, GPU_bool use_desktop_resolution);

DECLSPEC GPU_bool SDLCALL GPU_GetFullscreen(void);

DECLSPEC void SDLCALL GPU_SetShapeBlending(GPU_bool enable);

DECLSPEC GPU_BlendMode SDLCALL GPU_GetBlendModeFromPreset(GPU_BlendPresetEnum preset);

DECLSPEC void SDLCALL GPU_SetShapeBlendFunction(GPU_BlendFuncEnum source_color, GPU_BlendFuncEnum dest_color, GPU_BlendFuncEnum source_alpha, GPU_BlendFuncEnum dest_alpha);

DECLSPEC void SDLCALL GPU_SetShapeBlendEquation(GPU_BlendEqEnum color_equation, GPU_BlendEqEnum alpha_equation);
    
DECLSPEC void SDLCALL GPU_SetShapeBlendMode(GPU_BlendPresetEnum mode);

DECLSPEC float SDLCALL GPU_SetLineThickness(float thickness);

DECLSPEC float SDLCALL GPU_GetLineThickness(void);

// End of ContextControls
DECLSPEC GPU_Target* SDLCALL GPU_CreateAliasTarget(GPU_Target* target);

DECLSPEC GPU_Target* SDLCALL GPU_LoadTarget(GPU_Image* image);

DECLSPEC void SDLCALL GPU_FreeTarget(GPU_Target* target);

DECLSPEC void SDLCALL GPU_SetVirtualResolution(GPU_Target* target, Uint16 w, Uint16 h);

DECLSPEC void SDLCALL GPU_GetVirtualResolution(GPU_Target* target, Uint16* w, Uint16* h);

DECLSPEC void SDLCALL GPU_GetVirtualCoords(GPU_Target* target, float* x, float* y, float displayX, float displayY);

DECLSPEC void SDLCALL GPU_UnsetVirtualResolution(GPU_Target* target);

DECLSPEC GPU_Rect SDLCALL GPU_MakeRect(float x, float y, float w, float h);

DECLSPEC SDL_Color SDLCALL GPU_MakeColor(Uint8 r, Uint8 g, Uint8 b, Uint8 a);

DECLSPEC void SDLCALL GPU_SetViewport(GPU_Target* target, GPU_Rect viewport);

DECLSPEC void SDLCALL GPU_UnsetViewport(GPU_Target* target);

DECLSPEC GPU_Camera SDLCALL GPU_GetDefaultCamera(void);

DECLSPEC GPU_Camera SDLCALL GPU_GetCamera(GPU_Target* target);

DECLSPEC GPU_Camera SDLCALL GPU_SetCamera(GPU_Target* target, GPU_Camera* cam);

DECLSPEC void SDLCALL GPU_EnableCamera(GPU_Target* target, GPU_bool use_camera);

DECLSPEC GPU_bool SDLCALL GPU_IsCameraEnabled(GPU_Target* target);

DECLSPEC SDL_Color SDLCALL GPU_GetPixel(GPU_Target* target, Sint16 x, Sint16 y);

DECLSPEC GPU_Rect SDLCALL GPU_SetClipRect(GPU_Target* target, GPU_Rect rect);

DECLSPEC GPU_Rect SDLCALL GPU_SetClip(GPU_Target* target, Sint16 x, Sint16 y, Uint16 w, Uint16 h);

DECLSPEC void SDLCALL GPU_UnsetClip(GPU_Target* target);

DECLSPEC GPU_bool SDLCALL GPU_IntersectRect(GPU_Rect A, GPU_Rect B, GPU_Rect* result);

DECLSPEC GPU_bool SDLCALL GPU_IntersectClipRect(GPU_Target* target, GPU_Rect B, GPU_Rect* result);

DECLSPEC void SDLCALL GPU_SetTargetColor(GPU_Target* target, SDL_Color color);

DECLSPEC void SDLCALL GPU_SetTargetRGB(GPU_Target* target, Uint8 r, Uint8 g, Uint8 b);

DECLSPEC void SDLCALL GPU_SetTargetRGBA(GPU_Target* target, Uint8 r, Uint8 g, Uint8 b, Uint8 a);

DECLSPEC void SDLCALL GPU_UnsetTargetColor(GPU_Target* target);

// End of TargetControls
DECLSPEC SDL_Surface* SDLCALL GPU_LoadSurface(const char* filename);

DECLSPEC SDL_Surface* SDLCALL GPU_LoadSurface_RW(SDL_RWops* rwops, GPU_bool free_rwops);

DECLSPEC GPU_bool SDLCALL GPU_SaveSurface(SDL_Surface* surface, const char* filename, GPU_FileFormatEnum format);

DECLSPEC GPU_bool SDLCALL GPU_SaveSurface_RW(SDL_Surface* surface, SDL_RWops* rwops, GPU_bool free_rwops, GPU_FileFormatEnum format);

// End of SurfaceControls
DECLSPEC GPU_Image* SDLCALL GPU_CreateImage(Uint16 w, Uint16 h, GPU_FormatEnum format);

DECLSPEC GPU_Image* SDLCALL GPU_CreateImageUsingTexture(Uint32 handle, GPU_bool take_ownership);

DECLSPEC GPU_Image* SDLCALL GPU_LoadImage(const char* filename);

DECLSPEC GPU_Image* SDLCALL GPU_LoadImage_RW(SDL_RWops* rwops, GPU_bool free_rwops);

DECLSPEC GPU_Image* SDLCALL GPU_CreateAliasImage(GPU_Image* image);

DECLSPEC GPU_Image* SDLCALL GPU_CopyImage(GPU_Image* image);

DECLSPEC void SDLCALL GPU_FreeImage(GPU_Image* image);

DECLSPEC void SDLCALL GPU_SetImageVirtualResolution(GPU_Image* image, Uint16 w, Uint16 h);

DECLSPEC void SDLCALL GPU_UnsetImageVirtualResolution(GPU_Image* image);

DECLSPEC void SDLCALL GPU_UpdateImage(GPU_Image* image, const GPU_Rect* image_rect, SDL_Surface* surface, const GPU_Rect* surface_rect);

DECLSPEC void SDLCALL GPU_UpdateImageBytes(GPU_Image* image, const GPU_Rect* image_rect, const unsigned char* bytes, int bytes_per_row);

DECLSPEC GPU_bool SDLCALL GPU_ReplaceImage(GPU_Image* image, SDL_Surface* surface, const GPU_Rect* surface_rect);

DECLSPEC GPU_bool SDLCALL GPU_SaveImage(GPU_Image* image, const char* filename, GPU_FileFormatEnum format);

DECLSPEC GPU_bool SDLCALL GPU_SaveImage_RW(GPU_Image* image, SDL_RWops* rwops, GPU_bool free_rwops, GPU_FileFormatEnum format);

DECLSPEC void SDLCALL GPU_GenerateMipmaps(GPU_Image* image);

DECLSPEC void SDLCALL GPU_SetColor(GPU_Image* image, SDL_Color color);

DECLSPEC void SDLCALL GPU_SetRGB(GPU_Image* image, Uint8 r, Uint8 g, Uint8 b);

DECLSPEC void SDLCALL GPU_SetRGBA(GPU_Image* image, Uint8 r, Uint8 g, Uint8 b, Uint8 a);

DECLSPEC void SDLCALL GPU_UnsetColor(GPU_Image* image);

DECLSPEC GPU_bool SDLCALL GPU_GetBlending(GPU_Image* image);

DECLSPEC void SDLCALL GPU_SetBlending(GPU_Image* image, GPU_bool enable);

DECLSPEC void SDLCALL GPU_SetBlendFunction(GPU_Image* image, GPU_BlendFuncEnum source_color, GPU_BlendFuncEnum dest_color, GPU_BlendFuncEnum source_alpha, GPU_BlendFuncEnum dest_alpha);

DECLSPEC void SDLCALL GPU_SetBlendEquation(GPU_Image* image, GPU_BlendEqEnum color_equation, GPU_BlendEqEnum alpha_equation);

DECLSPEC void SDLCALL GPU_SetBlendMode(GPU_Image* image, GPU_BlendPresetEnum mode);

DECLSPEC void SDLCALL GPU_SetImageFilter(GPU_Image* image, GPU_FilterEnum filter);

DECLSPEC void SDLCALL GPU_SetAnchor(GPU_Image* image, float anchor_x, float anchor_y);

DECLSPEC void SDLCALL GPU_GetAnchor(GPU_Image* image, float* anchor_x, float* anchor_y);

DECLSPEC GPU_SnapEnum SDLCALL GPU_GetSnapMode(GPU_Image* image);

DECLSPEC void SDLCALL GPU_SetSnapMode(GPU_Image* image, GPU_SnapEnum mode);

DECLSPEC void SDLCALL GPU_SetWrapMode(GPU_Image* image, GPU_WrapEnum wrap_mode_x, GPU_WrapEnum wrap_mode_y);

// End of ImageControls
// Surface / Image / Target conversions
DECLSPEC GPU_Image* SDLCALL GPU_CopyImageFromSurface(SDL_Surface* surface);

DECLSPEC GPU_Image* SDLCALL GPU_CopyImageFromTarget(GPU_Target* target);

DECLSPEC SDL_Surface* SDLCALL GPU_CopySurfaceFromTarget(GPU_Target* target);

DECLSPEC SDL_Surface* SDLCALL GPU_CopySurfaceFromImage(GPU_Image* image);

// End of Conversions
// Basic vector operations (3D)

DECLSPEC float SDLCALL GPU_VectorLength(float* vec3);

DECLSPEC void SDLCALL GPU_VectorNormalize(float* vec3);

DECLSPEC float SDLCALL GPU_VectorDot(float* A, float* B);

DECLSPEC void SDLCALL GPU_VectorCross(float* result, float* A, float* B);

DECLSPEC void SDLCALL GPU_VectorCopy(float* result, float* A);

DECLSPEC void SDLCALL GPU_VectorApplyMatrix(float* vec3, float* matrix_4x4);



// Basic matrix operations (4x4)

DECLSPEC void SDLCALL GPU_MatrixCopy(float* result, const float* A);

DECLSPEC void SDLCALL GPU_MatrixIdentity(float* result);

DECLSPEC void SDLCALL GPU_MatrixOrtho(float* result, float left, float right, float bottom, float top, float near, float far);

DECLSPEC void SDLCALL GPU_MatrixFrustum(float* result, float left, float right, float bottom, float top, float near, float far);

DECLSPEC void SDLCALL GPU_MatrixPerspective(float* result, float fovy, float aspect, float zNear, float zFar);

DECLSPEC void SDLCALL GPU_MatrixLookAt(float* matrix, float eye_x, float eye_y, float eye_z, float target_x, float target_y, float target_z, float up_x, float up_y, float up_z);

DECLSPEC void SDLCALL GPU_MatrixTranslate(float* result, float x, float y, float z);

DECLSPEC void SDLCALL GPU_MatrixScale(float* result, float sx, float sy, float sz);

DECLSPEC void SDLCALL GPU_MatrixRotate(float* result, float degrees, float x, float y, float z);

DECLSPEC void SDLCALL GPU_Multiply4x4(float* result, float* A, float* B);

DECLSPEC void SDLCALL GPU_MultiplyAndAssign(float* result, float* B);


// Matrix stack accessors

DECLSPEC const char* SDLCALL GPU_GetMatrixString(float* A);

DECLSPEC float* SDLCALL GPU_GetCurrentMatrix(void);

DECLSPEC float* SDLCALL GPU_GetModelView(void);

DECLSPEC float* SDLCALL GPU_GetProjection(void);

DECLSPEC void SDLCALL GPU_GetModelViewProjection(float* result);


// Matrix stack manipulators

DECLSPEC void SDLCALL GPU_MatrixMode(int matrix_mode);

DECLSPEC void SDLCALL GPU_PushMatrix(void);

DECLSPEC void SDLCALL GPU_PopMatrix(void);

DECLSPEC void SDLCALL GPU_LoadIdentity(void);

DECLSPEC void SDLCALL GPU_Ortho(float left, float right, float bottom, float top, float near, float far);

DECLSPEC void SDLCALL GPU_Frustum(float left, float right, float bottom, float top, float near, float far);

DECLSPEC void SDLCALL GPU_Translate(float x, float y, float z);

DECLSPEC void SDLCALL GPU_Scale(float sx, float sy, float sz);

DECLSPEC void SDLCALL GPU_Rotate(float degrees, float x, float y, float z);

DECLSPEC void SDLCALL GPU_MultMatrix(float* matrix4x4);

// End of Matrix
DECLSPEC void SDLCALL GPU_Clear(GPU_Target* target);

DECLSPEC void SDLCALL GPU_ClearColor(GPU_Target* target, SDL_Color color);

DECLSPEC void SDLCALL GPU_ClearRGB(GPU_Target* target, Uint8 r, Uint8 g, Uint8 b);

DECLSPEC void SDLCALL GPU_ClearRGBA(GPU_Target* target, Uint8 r, Uint8 g, Uint8 b, Uint8 a);

DECLSPEC void SDLCALL GPU_Blit(GPU_Image* image, GPU_Rect* src_rect, GPU_Target* target, float x, float y);

DECLSPEC void SDLCALL GPU_BlitRotate(GPU_Image* image, GPU_Rect* src_rect, GPU_Target* target, float x, float y, float degrees);

DECLSPEC void SDLCALL GPU_BlitScale(GPU_Image* image, GPU_Rect* src_rect, GPU_Target* target, float x, float y, float scaleX, float scaleY);

DECLSPEC void SDLCALL GPU_BlitTransform(GPU_Image* image, GPU_Rect* src_rect, GPU_Target* target, float x, float y, float degrees, float scaleX, float scaleY);

DECLSPEC void SDLCALL GPU_BlitTransformX(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);

DECLSPEC void SDLCALL GPU_BlitRect(GPU_Image* image, GPU_Rect* src_rect, GPU_Target* target, GPU_Rect* dest_rect);

DECLSPEC void SDLCALL GPU_BlitRectX(GPU_Image* image, GPU_Rect* src_rect, GPU_Target* target, GPU_Rect* dest_rect, float degrees, float pivot_x, float pivot_y, GPU_FlipEnum flip_direction);


DECLSPEC void SDLCALL GPU_TriangleBatch(GPU_Image* image, GPU_Target* target, unsigned short num_vertices, float* values, unsigned int num_indices, unsigned short* indices, GPU_BatchFlagEnum flags);

DECLSPEC void SDLCALL GPU_TriangleBatchX(GPU_Image* image, GPU_Target* target, unsigned short num_vertices, void* values, unsigned int num_indices, unsigned short* indices, GPU_BatchFlagEnum flags);

DECLSPEC void SDLCALL GPU_FlushBlitBuffer(void);

DECLSPEC void SDLCALL GPU_Flip(GPU_Target* target);

// End of Rendering
DECLSPEC void SDLCALL GPU_Pixel(GPU_Target* target, float x, float y, SDL_Color color);

DECLSPEC void SDLCALL GPU_Line(GPU_Target* target, float x1, float y1, float x2, float y2, SDL_Color color);

DECLSPEC void SDLCALL GPU_Arc(GPU_Target* target, float x, float y, float radius, float start_angle, float end_angle, SDL_Color color);

DECLSPEC void SDLCALL GPU_ArcFilled(GPU_Target* target, float x, float y, float radius, float start_angle, float end_angle, SDL_Color color);

DECLSPEC void SDLCALL GPU_Circle(GPU_Target* target, float x, float y, float radius, SDL_Color color);

DECLSPEC void SDLCALL GPU_CircleFilled(GPU_Target* target, float x, float y, float radius, SDL_Color color);

DECLSPEC void SDLCALL GPU_Ellipse(GPU_Target* target, float x, float y, float rx, float ry, float degrees, SDL_Color color);

DECLSPEC void SDLCALL GPU_EllipseFilled(GPU_Target* target, float x, float y, float rx, float ry, float degrees, SDL_Color color);

DECLSPEC void SDLCALL GPU_Sector(GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float start_angle, float end_angle, SDL_Color color);

DECLSPEC void SDLCALL GPU_SectorFilled(GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float start_angle, float end_angle, SDL_Color color);

DECLSPEC void SDLCALL GPU_Tri(GPU_Target* target, float x1, float y1, float x2, float y2, float x3, float y3, SDL_Color color);

DECLSPEC void SDLCALL GPU_TriFilled(GPU_Target* target, float x1, float y1, float x2, float y2, float x3, float y3, SDL_Color color);

DECLSPEC void SDLCALL GPU_Rectangle(GPU_Target* target, float x1, float y1, float x2, float y2, SDL_Color color);

DECLSPEC void SDLCALL GPU_Rectangle2(GPU_Target* target, GPU_Rect rect, SDL_Color color);

DECLSPEC void SDLCALL GPU_RectangleFilled(GPU_Target* target, float x1, float y1, float x2, float y2, SDL_Color color);

DECLSPEC void SDLCALL GPU_RectangleFilled2(GPU_Target* target, GPU_Rect rect, SDL_Color color);

DECLSPEC void SDLCALL GPU_RectangleRound(GPU_Target* target, float x1, float y1, float x2, float y2, float radius, SDL_Color color);

DECLSPEC void SDLCALL GPU_RectangleRound2(GPU_Target* target, GPU_Rect rect, float radius, SDL_Color color);

DECLSPEC void SDLCALL GPU_RectangleRoundFilled(GPU_Target* target, float x1, float y1, float x2, float y2, float radius, SDL_Color color);

DECLSPEC void SDLCALL GPU_RectangleRoundFilled2(GPU_Target* target, GPU_Rect rect, float radius, SDL_Color color);

DECLSPEC void SDLCALL GPU_Polygon(GPU_Target* target, unsigned int num_vertices, float* vertices, SDL_Color color);

DECLSPEC void SDLCALL GPU_PolygonFilled(GPU_Target* target, unsigned int num_vertices, float* vertices, SDL_Color color);

// End of Shapes
DECLSPEC Uint32 SDLCALL GPU_CreateShaderProgram(void);

DECLSPEC void SDLCALL GPU_FreeShaderProgram(Uint32 program_object);

DECLSPEC Uint32 SDLCALL GPU_CompileShader_RW(GPU_ShaderEnum shader_type, SDL_RWops* shader_source, GPU_bool free_rwops);

DECLSPEC Uint32 SDLCALL GPU_CompileShader(GPU_ShaderEnum shader_type, const char* shader_source);

DECLSPEC Uint32 SDLCALL GPU_LoadShader(GPU_ShaderEnum shader_type, const char* filename);

DECLSPEC Uint32 SDLCALL GPU_LinkShaders(Uint32 shader_object1, Uint32 shader_object2);

DECLSPEC Uint32 SDLCALL GPU_LinkManyShaders(Uint32 *shader_objects, int count);

DECLSPEC void SDLCALL GPU_FreeShader(Uint32 shader_object);

DECLSPEC void SDLCALL GPU_AttachShader(Uint32 program_object, Uint32 shader_object);

DECLSPEC void SDLCALL GPU_DetachShader(Uint32 program_object, Uint32 shader_object);

DECLSPEC GPU_bool SDLCALL GPU_LinkShaderProgram(Uint32 program_object);

DECLSPEC Uint32 SDLCALL GPU_GetCurrentShaderProgram(void);

DECLSPEC GPU_bool SDLCALL GPU_IsDefaultShaderProgram(Uint32 program_object);

DECLSPEC void SDLCALL GPU_ActivateShaderProgram(Uint32 program_object, GPU_ShaderBlock* block);

DECLSPEC void SDLCALL GPU_DeactivateShaderProgram(void);

DECLSPEC const char* SDLCALL GPU_GetShaderMessage(void);

DECLSPEC int SDLCALL GPU_GetAttributeLocation(Uint32 program_object, const char* attrib_name);

DECLSPEC GPU_AttributeFormat SDLCALL GPU_MakeAttributeFormat(int num_elems_per_vertex, GPU_TypeEnum type, GPU_bool normalize, int stride_bytes, int offset_bytes);

DECLSPEC GPU_Attribute SDLCALL GPU_MakeAttribute(int location, void* values, GPU_AttributeFormat format);

DECLSPEC int SDLCALL GPU_GetUniformLocation(Uint32 program_object, const char* uniform_name);

DECLSPEC GPU_ShaderBlock SDLCALL GPU_LoadShaderBlock(Uint32 program_object, const char* position_name, const char* texcoord_name, const char* color_name, const char* modelViewMatrix_name);

DECLSPEC void SDLCALL GPU_SetShaderBlock(GPU_ShaderBlock block);

DECLSPEC GPU_ShaderBlock SDLCALL GPU_GetShaderBlock(void);

DECLSPEC void SDLCALL GPU_SetShaderImage(GPU_Image* image, int location, int image_unit);

DECLSPEC void SDLCALL GPU_GetUniformiv(Uint32 program_object, int location, int* values);

DECLSPEC void SDLCALL GPU_SetUniformi(int location, int value);

DECLSPEC void SDLCALL GPU_SetUniformiv(int location, int num_elements_per_value, int num_values, int* values);

DECLSPEC void SDLCALL GPU_GetUniformuiv(Uint32 program_object, int location, unsigned int* values);

DECLSPEC void SDLCALL GPU_SetUniformui(int location, unsigned int value);

DECLSPEC void SDLCALL GPU_SetUniformuiv(int location, int num_elements_per_value, int num_values, unsigned int* values);

DECLSPEC void SDLCALL GPU_GetUniformfv(Uint32 program_object, int location, float* values);

DECLSPEC void SDLCALL GPU_SetUniformf(int location, float value);

DECLSPEC void SDLCALL GPU_SetUniformfv(int location, int num_elements_per_value, int num_values, float* values);

DECLSPEC void SDLCALL GPU_GetUniformMatrixfv(Uint32 program_object, int location, float* values);

DECLSPEC void SDLCALL GPU_SetUniformMatrixfv(int location, int num_matrices, int num_rows, int num_columns, GPU_bool transpose, float* values);

DECLSPEC void SDLCALL GPU_SetAttributef(int location, float value);

DECLSPEC void SDLCALL GPU_SetAttributei(int location, int value);

DECLSPEC void SDLCALL GPU_SetAttributeui(int location, unsigned int value);

DECLSPEC void SDLCALL GPU_SetAttributefv(int location, int num_elements, float* value);

DECLSPEC void SDLCALL GPU_SetAttributeiv(int location, int num_elements, int* value);

DECLSPEC void SDLCALL GPU_SetAttributeuiv(int location, int num_elements, unsigned int* value);

DECLSPEC void SDLCALL GPU_SetAttributeSource(int num_values, GPU_Attribute source);

// End of ShaderInterface
#ifdef __cplusplus
}
#endif

#include "close_code.h"


#endif