SDL_gpu.h

#ifndef _SDL_GPU_H__
#define _SDL_GPU_H__
 
#ifndef _USE_MATH_DEFINES
#define _USE_MATH_DEFINES // So M_PI and company get defined on MSVC when we include math.h
#endif
#include <math.h> // Must be included before SDL.h, otherwise both try to define M_PI and we get a warning
 
#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 version info
#include "SDL_gpu_version.h"
 
/* 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
 
#if defined(_MSC_VER) || (defined(__INTEL_COMPILER) && defined(_WIN32))
   #if defined(_M_X64)
      #define SDL_GPU_BITNESS 64
   #else
      #define SDL_GPU_BITNESS 32
   #endif
   #define SDL_GPU_LONG_SIZE 4
#elif defined(__clang__) || defined(__INTEL_COMPILER) || defined(__GNUC__)
   #if defined(__x86_64)
      #define SDL_GPU_BITNESS 64
   #else
      #define SDL_GPU_BITNESS 32
   #endif
   #if __LONG_MAX__ == 2147483647L
      #define SDL_GPU_LONG_SIZE 4
   #else
      #define SDL_GPU_LONG_SIZE 8
   #endif
#endif
 
// Struct padding for 32 or 64 bit alignment
#if SDL_GPU_BITNESS == 32
#define GPU_PAD_1_TO_32 char _padding[1];
#define GPU_PAD_2_TO_32 char _padding[2];
#define GPU_PAD_3_TO_32 char _padding[3];
#define GPU_PAD_1_TO_64 char _padding[1];
#define GPU_PAD_2_TO_64 char _padding[2];
#define GPU_PAD_3_TO_64 char _padding[3];
#define GPU_PAD_4_TO_64 
#define GPU_PAD_5_TO_64 char _padding[1];
#define GPU_PAD_6_TO_64 char _padding[2];
#define GPU_PAD_7_TO_64 char _padding[3];
#elif SDL_GPU_BITNESS == 64
#define GPU_PAD_1_TO_32 char _padding[1];
#define GPU_PAD_2_TO_32 char _padding[2];
#define GPU_PAD_3_TO_32 char _padding[3];
#define GPU_PAD_1_TO_64 char _padding[1];
#define GPU_PAD_2_TO_64 char _padding[2];
#define GPU_PAD_3_TO_64 char _padding[3];
#define GPU_PAD_4_TO_64 char _padding[4];
#define GPU_PAD_5_TO_64 char _padding[5];
#define GPU_PAD_6_TO_64 char _padding[6];
#define GPU_PAD_7_TO_64 char _padding[7];
#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_PAD_4_TO_64
} GPU_RendererID;
 
 
typedef enum {
    GPU_NEVER = 0x0200,
    GPU_LESS = 0x0201,
    GPU_EQUAL = 0x0202,
    GPU_LEQUAL = 0x0203,
    GPU_GREATER = 0x0204,
    GPU_NOTEQUAL = 0x0205,
    GPU_GEQUAL = 0x0206,
    GPU_ALWAYS = 0x0207
} GPU_ComparisonEnum;
 
 
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_FORMAT_BGR = 9,
    GPU_FORMAT_BGRA = 10,
    GPU_FORMAT_ABGR = 11
} 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;
    void* data;
    
    Uint16 w, h;
    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
    
    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_BlendMode blend_mode;
    GPU_FilterEnum filter_mode;
    GPU_SnapEnum snap_mode;
    GPU_WrapEnum wrap_mode_x;
    GPU_WrapEnum wrap_mode_y;
    
    int refcount;
    
    GPU_bool using_virtual_resolution;
    GPU_bool has_mipmaps;
    GPU_bool use_blending;
    GPU_bool is_alias;
} GPU_Image;
 
typedef uintptr_t GPU_TextureHandle;
 
 
typedef struct GPU_Camera
{
    float x, y, z;
    float angle;
    float zoom_x, zoom_y;
    float z_near, z_far;  // z clipping planes
    GPU_bool use_centered_origin;  // move rotation/scaling origin to the center of the camera's view
    
    GPU_PAD_7_TO_64
} GPU_Camera;
 
 
typedef struct GPU_ShaderBlock
{
    // Attributes
    int position_loc;
    int texcoord_loc;
    int color_loc;
    // Uniforms
    int modelViewProjection_loc;
} GPU_ShaderBlock;
 
 
 
 
 
#define GPU_MODEL 0
#define GPU_VIEW 1
#define GPU_PROJECTION 2
 
typedef struct GPU_MatrixStack
{
    unsigned int storage_size;
    unsigned int size;
    float** matrix;
} GPU_MatrixStack;
 
 
typedef struct GPU_Context
{
    void* context;
    
    GPU_Target* active_target;
    
    GPU_ShaderBlock current_shader_block;
    GPU_ShaderBlock default_textured_shader_block;
    GPU_ShaderBlock default_untextured_shader_block;
    
    
    Uint32 windowID;
    
    int window_w;
    int window_h;
    
    int drawable_w;
    int drawable_h;
    
    int stored_window_w;
    int stored_window_h;
    
    Uint32 default_textured_vertex_shader_id;
    Uint32 default_textured_fragment_shader_id;
    Uint32 default_untextured_vertex_shader_id;
    Uint32 default_untextured_fragment_shader_id;
    
    
    
    Uint32 current_shader_program;
    Uint32 default_textured_shader_program;
    Uint32 default_untextured_shader_program;
    
    GPU_BlendMode shapes_blend_mode;
    float line_thickness;
    
    int refcount;
    
    void* data;
    
    GPU_bool failed;
    GPU_bool use_texturing;
    GPU_bool shapes_use_blending;
    
    GPU_PAD_5_TO_64
} GPU_Context;
 
 
struct GPU_Target
{
    struct GPU_Renderer* renderer;
    GPU_Target* context_target;
    GPU_Image* image;
    void* data;
    Uint16 w, h;
    Uint16 base_w, base_h;  // The true dimensions of the underlying image or window
    GPU_Rect clip_rect;
    SDL_Color color;
    
    GPU_Rect viewport;
    
    int matrix_mode;
    GPU_MatrixStack projection_matrix;
    GPU_MatrixStack view_matrix;
    GPU_MatrixStack model_matrix;
 
    GPU_Camera camera;
    
    GPU_bool using_virtual_resolution;
    GPU_bool use_clip_rect;
    GPU_bool use_color;
    GPU_bool use_camera;
 
    
    GPU_ComparisonEnum depth_function;
    
    GPU_Context* context;
    int refcount;
    
    GPU_bool use_depth_test;
    GPU_bool use_depth_write;
    GPU_bool is_alias;
    
    GPU_PAD_1_TO_64
};
 
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;
static const GPU_FeatureEnum GPU_FEATURE_CORE_FRAMEBUFFER_OBJECTS = 0x1000;
 
#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;
static const GPU_InitFlagEnum GPU_INIT_USE_ROW_BY_ROW_TEXTURE_UPLOAD_FALLBACK = 0x20;
static const GPU_InitFlagEnum GPU_INIT_USE_COPY_TEXTURE_UPLOAD_FALLBACK = 0x40;
 
#define GPU_DEFAULT_INIT_FLAGS 0
 
 
static const Uint32 GPU_NONE = 0x0;
 
typedef Uint32 GPU_PrimitiveEnum;
static const GPU_PrimitiveEnum GPU_POINTS = 0x0;
static const GPU_PrimitiveEnum GPU_LINES = 0x1;
static const GPU_PrimitiveEnum GPU_LINE_LOOP = 0x2;
static const GPU_PrimitiveEnum GPU_LINE_STRIP = 0x3;
static const GPU_PrimitiveEnum GPU_TRIANGLES = 0x4;
static const GPU_PrimitiveEnum GPU_TRIANGLE_STRIP = 0x5;
static const GPU_PrimitiveEnum GPU_TRIANGLE_FAN = 0x6;
 
 
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
{
    int num_elems_per_value;
    GPU_TypeEnum type;  // GPU_TYPE_FLOAT, GPU_TYPE_INT, GPU_TYPE_UNSIGNED_INT, etc.
    int stride_bytes;  // Number of bytes between two vertex specifications
    int offset_bytes;  // Number of bytes to skip at the beginning of 'values'
    GPU_bool is_per_sprite;  // Per-sprite values are expanded to 4 vertices
    GPU_bool normalize;
    
    GPU_PAD_2_TO_32
} GPU_AttributeFormat;
 
typedef struct GPU_Attribute
{
    void* values;  // Expect 4 values for each sprite
    GPU_AttributeFormat format;
    int location;
    
    GPU_PAD_4_TO_64
} GPU_Attribute;
 
typedef struct GPU_AttributeSource
{
    void* next_value;
    void* per_vertex_storage;  // Could point to the attribute's values or to allocated storage
    
    int num_values;
    // 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
    GPU_Attribute attribute;
    GPU_bool enabled;
    
    GPU_PAD_7_TO_64
} 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;
    char* details;
    GPU_ErrorEnum error;
    
    GPU_PAD_4_TO_64
} 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;
    
    float default_image_anchor_x;
    float default_image_anchor_y;
    
    struct GPU_RendererImpl* impl;
    
    GPU_bool coordinate_mode;
    
    GPU_PAD_7_TO_64
};
 
 
 
 
 
 
// 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 GPU_Target* SDLCALL GPU_GetActiveTarget(void);
 
DECLSPEC GPU_bool SDLCALL GPU_SetActiveTarget(GPU_Target* target);
 
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 GPU_Target* SDLCALL GPU_GetTarget(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 GPU_bool SDLCALL GPU_AddDepthBuffer(GPU_Target* target);
 
DECLSPEC void SDLCALL GPU_SetDepthTest(GPU_Target* target, GPU_bool enable);
 
DECLSPEC void SDLCALL GPU_SetDepthWrite(GPU_Target* target, GPU_bool enable);
 
DECLSPEC void SDLCALL GPU_SetDepthFunction(GPU_Target* target, GPU_ComparisonEnum compare_operation);
 
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(GPU_TextureHandle 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);
 
DECLSPEC GPU_TextureHandle SDLCALL GPU_GetTextureHandle(GPU_Image* image);
 
// End of ImageControls
// Surface / Image / Target conversions
DECLSPEC GPU_Image* SDLCALL GPU_CopyImageFromSurface(SDL_Surface* surface);
 
DECLSPEC GPU_Image* SDLCALL GPU_CopyImageFromSurfaceRect(SDL_Surface* surface, GPU_Rect* surface_rect);
 
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(const float* vec3);
 
DECLSPEC void SDLCALL GPU_VectorNormalize(float* vec3);
 
DECLSPEC float SDLCALL GPU_VectorDot(const float* A, const float* B);
 
DECLSPEC void SDLCALL GPU_VectorCross(float* result, const float* A, const float* B);
 
DECLSPEC void SDLCALL GPU_VectorCopy(float* result, const float* A);
 
DECLSPEC void SDLCALL GPU_VectorApplyMatrix(float* vec3, const float* matrix_4x4);
 
DECLSPEC void SDLCALL GPU_Vector4ApplyMatrix(float* vec4, const 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 z_near, float z_far);
 
DECLSPEC void SDLCALL GPU_MatrixFrustum(float* result, float left, float right, float bottom, float top, float z_near, float z_far);
 
DECLSPEC void SDLCALL GPU_MatrixPerspective(float* result, float fovy, float aspect, float z_near, float z_far);
 
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_MatrixMultiply(float* result, const float* A, const float* B);
 
DECLSPEC void SDLCALL GPU_MultiplyAndAssign(float* result, const float* B);
 
 
// Matrix stack accessors
 
DECLSPEC const char* SDLCALL GPU_GetMatrixString(const float* A);
 
DECLSPEC float* SDLCALL GPU_GetCurrentMatrix(void);
 
DECLSPEC float* SDLCALL GPU_GetTopMatrix(GPU_MatrixStack* stack);
 
DECLSPEC float* SDLCALL GPU_GetModel(void);
 
DECLSPEC float* SDLCALL GPU_GetView(void);
 
DECLSPEC float* SDLCALL GPU_GetProjection(void);
 
DECLSPEC void SDLCALL GPU_GetModelViewProjection(float* result);
 
 
// Matrix stack manipulators
 
DECLSPEC GPU_MatrixStack* SDLCALL GPU_CreateMatrixStack(void);
 
DECLSPEC void SDLCALL GPU_FreeMatrixStack(GPU_MatrixStack* stack);
 
DECLSPEC void SDLCALL GPU_InitMatrixStack(GPU_MatrixStack* stack);
 
DECLSPEC void SDLCALL GPU_CopyMatrixStack(const GPU_MatrixStack* source, GPU_MatrixStack* dest);
 
DECLSPEC void SDLCALL GPU_ClearMatrixStack(GPU_MatrixStack* stack);
 
DECLSPEC void SDLCALL GPU_ResetProjection(GPU_Target* target);
 
DECLSPEC void SDLCALL GPU_MatrixMode(GPU_Target* target, int matrix_mode);
 
DECLSPEC void SDLCALL GPU_SetProjection(const float* A);
 
DECLSPEC void SDLCALL GPU_SetView(const float* A);
 
DECLSPEC void SDLCALL GPU_SetModel(const float* A);
 
DECLSPEC void SDLCALL GPU_SetProjectionFromStack(GPU_MatrixStack* stack);
 
DECLSPEC void SDLCALL GPU_SetViewFromStack(GPU_MatrixStack* stack);
 
DECLSPEC void SDLCALL GPU_SetModelFromStack(GPU_MatrixStack* stack);
 
DECLSPEC void SDLCALL GPU_PushMatrix(void);
 
DECLSPEC void SDLCALL GPU_PopMatrix(void);
 
DECLSPEC void SDLCALL GPU_LoadIdentity(void);
 
DECLSPEC void SDLCALL GPU_LoadMatrix(const float* matrix4x4);
 
DECLSPEC void SDLCALL GPU_Ortho(float left, float right, float bottom, float top, float z_near, float z_far);
 
DECLSPEC void SDLCALL GPU_Frustum(float left, float right, float bottom, float top, float z_near, float z_far);
 
DECLSPEC void SDLCALL GPU_Perspective(float fovy, float aspect, float z_near, float z_far);
 
DECLSPEC void SDLCALL GPU_LookAt(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_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(const 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_PrimitiveBatch(GPU_Image* image, GPU_Target* target, GPU_PrimitiveEnum primitive_type, unsigned short num_vertices, float* values, unsigned int num_indices, unsigned short* indices, GPU_BatchFlagEnum flags);
 
DECLSPEC void SDLCALL GPU_PrimitiveBatchV(GPU_Image* image, GPU_Target* target, GPU_PrimitiveEnum primitive_type, 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_Polyline(GPU_Target* target, unsigned int num_vertices, float* vertices, SDL_Color color, GPU_bool close_loop);
    
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