refactor names from e.g. sdl2::init() to sdl2::SDL_Init()

Signed-off-by: Vlad-Stefan Harbuz <vlad@vladh.net>

1 files changed, 79 insertions, 79 deletions

diff --git a/sdl2/render.ha b/sdl2/render.ha
index 2c53183..d607712 100644
--- a/sdl2/render.ha
+++ b/sdl2/render.ha
@@ -1,13 +1,13 @@
 // TODO: Flesh me out
 
 // A structure representing rendering state. (Opaque)
-export type renderer = void;
+export type SDL_Renderer = void;
 
 // An efficient driver-specific representation of pixel data. (Opaque)
-export type texture = void;
+export type SDL_Texture = void;
 
 // Flags used when creating a rendering context.
-export type renderer_flags = enum u32 {
+export type SDL_RendererFlags = enum u32 {
 	NONE = 0,
 	SOFTWARE = 0x00000001,
 	ACCELERATED = 0x00000002,
@@ -15,96 +15,96 @@ export type renderer_flags = enum u32 {
 	TARGETTEXTURE = 0x00000008,
 };
 
-@symbol("SDL_CreateWindowAndRenderer") fn _create_window_and_renderer(
-	width: int, height: int, window_flags: window_flags,
-	window: nullable **window, renderer: nullable **renderer) int;
+@symbol("SDL_CreateWindowAndRenderer") fn _SDL_CreateWindowAndRenderer(
+	width: int, height: int, SDL_WindowFlags: SDL_WindowFlags,
+	window: nullable **SDL_Window, renderer: nullable **SDL_Renderer) int;
 
 // Create a window and default renderer.
 //
 // 'width' and 'height' set the width and height of the window, in screen
-// coordinates. 'window_flags' configure additional window parameters.
+// coordinates. 'SDL_WindowFlags' configure additional window parameters.
 //
 // 'window' and 'renderer' are out parameters, or null, which are filled in with
 // the created window and renderer respectively.
-export fn create_window_and_renderer(
+export fn SDL_CreateWindowAndRenderer(
 	width: int,
 	height: int,
-	window_flags: window_flags,
-	window: nullable **window,
-	renderer: nullable **renderer,
-) (void | error) = wrapvoid(_create_window_and_renderer(width, height,
-	window_flags, window, renderer));
+	SDL_WindowFlags: SDL_WindowFlags,
+	window: nullable **SDL_Window,
+	renderer: nullable **SDL_Renderer,
+) (void | error) = wrapvoid(_SDL_CreateWindowAndRenderer(width, height,
+	SDL_WindowFlags, window, renderer));
 
-@symbol("SDL_CreateRenderer") fn _create_renderer(window: *window,
-	index: int, flags: renderer_flags) nullable *renderer;
+@symbol("SDL_CreateRenderer") fn _SDL_CreateRenderer(window: *SDL_Window,
+	index: int, flags: SDL_RendererFlags) nullable *SDL_Renderer;
 
 // Create a 2D rendering context for a window.
-// 
+//
 // 'window' is the window where rendering is displayed. 'index' is the index of
 // the rendering driver to initialize, or -1 to initialize the first one
 // supporting the requested flags.
-// 
+//
 // See also: [[create_software_renderer]], [[get_renderer_info]],
-// [[destroy_renderer]].
-export fn create_renderer(
-	window: *window,
+// [[SDL_DestroyRenderer]].
+export fn SDL_CreateRenderer(
+	window: *SDL_Window,
 	index: int,
-	flags: renderer_flags,
-) (*renderer | error) =
-	wrapptr(_create_renderer(window, index, flags))?: *renderer;
+	flags: SDL_RendererFlags,
+) (*SDL_Renderer | error) =
+	wrapptr(_SDL_CreateRenderer(window, index, flags))?: *SDL_Renderer;
 
 // Destroy the rendering context for a window and free associated textures.
 //
-// See also: [[create_renderer]].
-export @symbol("SDL_DestroyRenderer") fn destroy_renderer(renderer: *renderer) void;
+// See also: [[SDL_CreateRenderer]].
+export @symbol("SDL_DestroyRenderer") fn SDL_DestroyRenderer(renderer: *SDL_Renderer) void;
 
 // Opaque value for the alpha channel (255).
 export def ALPHA_OPAQUE: u8 = 255;
 
-@symbol("SDL_SetRenderDrawColor") fn _set_render_draw_color(renderer: *renderer,
+@symbol("SDL_SetRenderDrawColor") fn _SDL_SetRenderDrawColor(renderer: *SDL_Renderer,
 	r: u8, g: u8, b: u8, a: u8) int;
 
 // Set the color used for drawing operations (Rect, Line and Clear).
-// 
+//
 // 'renderer' is the renderer for which drawing color should be set. 'r', 'g',
 // 'b', and 'a' respectively set the red, gree, blue, and alpha channels.
-export fn set_render_draw_color(
-	renderer: *renderer,
+export fn SDL_SetRenderDrawColor(
+	renderer: *SDL_Renderer,
 	r: u8, g: u8, b: u8, a: u8,
-) (void | error) = wrapvoid(_set_render_draw_color(renderer, r, g, b, a));
+) (void | error) = wrapvoid(_SDL_SetRenderDrawColor(renderer, r, g, b, a));
 
-@symbol("SDL_RenderClear") fn _render_clear(renderer: *renderer) int;
+@symbol("SDL_RenderClear") fn _SDL_RenderClear(renderer: *SDL_Renderer) int;
 
 // Clear the current rendering target with the drawing color
 //
 // This function clears the entire rendering target, ignoring the viewport and
 // the clip rectangle.
-export fn render_clear(renderer: *renderer) (void | error) = {
-	return wrapvoid(_render_clear(renderer));
+export fn SDL_RenderClear(renderer: *SDL_Renderer) (void | error) = {
+	return wrapvoid(_SDL_RenderClear(renderer));
 };
 
 // Update the screen with rendering performed.
-export @symbol("SDL_RenderPresent") fn render_present(renderer: *renderer) void;
+export @symbol("SDL_RenderPresent") fn SDL_RenderPresent(renderer: *SDL_Renderer) void;
 
 // Destroy the specified texture.
-export @symbol("SDL_DestroyTexture") fn destroy_texture(texture: *texture) void;
+export @symbol("SDL_DestroyTexture") fn SDL_DestroyTexture(texture: *SDL_Texture) void;
 
-@symbol("SDL_QueryTexture") fn _query_texture(texture: *texture,
+@symbol("SDL_QueryTexture") fn _SDL_QueryTexture(texture: *SDL_Texture,
 	format: nullable *u32, access: nullable *int,
 	w: nullable *int, h: nullable *int) int;
 
 // Query the attributes of a texture
-export fn query_texture(
-	texture: *texture,
+export fn SDL_QueryTexture(
+	texture: *SDL_Texture,
 	format: nullable *u32,
 	access: nullable *int,
 	w: nullable *int, h: nullable *int,
 ) (void | error) = {
-	return wrapvoid(_query_texture(texture, format, access, w, h));
+	return wrapvoid(_SDL_QueryTexture(texture, format, access, w, h));
 };
 
-@symbol("SDL_SetTextureColorMod") fn _set_texture_color_mod(
-	texture: *texture, r: u8, g: u8, b: u8) int;
+@symbol("SDL_SetTextureColorMod") fn _SDL_SetTextureColorMod(
+	texture: *SDL_Texture, r: u8, g: u8, b: u8) int;
 
 // Set an additional color value multiplied into render copy operations.
 //
@@ -116,14 +116,14 @@ export fn query_texture(
 //
 // Color modulation is not always supported by the renderer; it will return -1
 // if color modulation is not supported.
-export fn set_texture_color_mod(
-	texture: *texture,
+export fn SDL_SetTextureColorMod(
+	texture: *SDL_Texture,
 	r: u8, g: u8, b: u8,
 ) (void | error) = {
-	return wrapvoid(_set_texture_color_mod(texture, r, g, b));
+	return wrapvoid(_SDL_SetTextureColorMod(texture, r, g, b));
 };
 
-@symbol("SDL_SetTextureAlphaMod") fn _set_texture_alpha_mod(texture: *texture, a: u8) int;
+@symbol("SDL_SetTextureAlphaMod") fn _SDL_SetTextureAlphaMod(texture: *SDL_Texture, a: u8) int;
 
 // Set an additional alpha value multiplied into render copy operations.
 //
@@ -134,64 +134,64 @@ export fn set_texture_color_mod(
 //
 // Alpha modulation is not always supported by the renderer; it will return an
 // error if alpha modulation is not supported.
-export fn set_texture_alpha_mod(texture: *texture, a: u8) (void | error) = {
+export fn SDL_SetTextureAlphaMod(texture: *SDL_Texture, a: u8) (void | error) = {
 	// TODO: Double check errors
-	return wrapvoid(_set_texture_alpha_mod(texture, a));
+	return wrapvoid(_SDL_SetTextureAlphaMod(texture, a));
 };
 
-@symbol("SDL_SetTextureBlendMode") fn _set_texture_blend_mode(
-	texture: *texture, mode: blend_mode) int;
+@symbol("SDL_SetTextureBlendMode") fn _SDL_SetTextureBlendMode(
+	texture: *SDL_Texture, mode: SDL_BlendMode) int;
 
 // Set the blend mode for a texture, used by SDL_RenderCopy().
-export fn set_texture_blend_mode(
-	texture: *texture,
-	mode: blend_mode,
+export fn SDL_SetTextureBlendMode(
+	texture: *SDL_Texture,
+	mode: SDL_BlendMode,
 ) (void | error) = {
-	return wrapvoid(_set_texture_blend_mode(texture, mode));
+	return wrapvoid(_SDL_SetTextureBlendMode(texture, mode));
 };
 
-@symbol("SDL_SetRenderDrawBlendMode") fn _set_render_draw_blend_mode(
-	renderer: *renderer, mode: blend_mode) int;
+@symbol("SDL_SetRenderDrawBlendMode") fn _SDL_SetRenderDrawBlendMode(
+	renderer: *SDL_Renderer, mode: SDL_BlendMode) int;
 
 // Set the blend mode used for drawing operations (fill and line).
-export fn set_render_draw_blend_mode(
-	renderer: *renderer,
-	mode: blend_mode,
+export fn SDL_SetRenderDrawBlendMode(
+	renderer: *SDL_Renderer,
+	mode: SDL_BlendMode,
 ) (void | error) = {
-	return wrapvoid(_set_render_draw_blend_mode(renderer, mode));
+	return wrapvoid(_SDL_SetRenderDrawBlendMode(renderer, mode));
 };
 
-@symbol("SDL_RenderCopy") fn _render_copy(renderer: *renderer,
-	texture: *texture, srcrect: nullable *rect, dstrect: nullable *rect) int;
+@symbol("SDL_RenderCopy") fn _SDL_RenderCopy(renderer: *SDL_Renderer,
+	texture: *SDL_Texture, srcrect: nullable *SDL_Rect, dstrect: nullable *SDL_Rect) int;
 
 // Copy a portion of the texture to the current rendering target.
-export fn render_copy(
-	renderer: *renderer,
-	texture: *texture,
-	srcrect: nullable *rect,
-	dstrect: nullable *rect,
+export fn SDL_RenderCopy(
+	renderer: *SDL_Renderer,
+	texture: *SDL_Texture,
+	srcrect: nullable *SDL_Rect,
+	dstrect: nullable *SDL_Rect,
 ) (void | error) = {
-	return wrapvoid(_render_copy(renderer, texture, srcrect, dstrect));
+	return wrapvoid(_SDL_RenderCopy(renderer, texture, srcrect, dstrect));
 };
 
-@symbol("SDL_RenderDrawRect") fn _render_draw_rect(
-	renderer: *renderer, rect: const nullable *rect) int;
+@symbol("SDL_RenderDrawRect") fn _SDL_RenderDrawRect(
+	renderer: *SDL_Renderer, rect: const nullable *SDL_Rect) int;
 
 // Draw a rectangle on the current rendering target.
-export fn render_draw_rect(
-	renderer: *renderer,
-	rect: const nullable *rect,
+export fn SDL_RenderDrawRect(
+	renderer: *SDL_Renderer,
+	rect: const nullable *SDL_Rect,
 ) (void | error) = {
-	return wrapvoid(_render_draw_rect(renderer, rect));
+	return wrapvoid(_SDL_RenderDrawRect(renderer, rect));
 };
 
-@symbol("SDL_RenderFillRect") fn _render_fill_rect(
-	renderer: *renderer, rect: const nullable *rect) int;
+@symbol("SDL_RenderFillRect") fn _SDL_RenderFillRect(
+	renderer: *SDL_Renderer, rect: const nullable *SDL_Rect) int;
 
 // Fills a rectangle on the current rendering target.
-export fn render_fill_rect(
-	renderer: *renderer,
-	rect: const nullable *rect,
+export fn SDL_RenderFillRect(
+	renderer: *SDL_Renderer,
+	rect: const nullable *SDL_Rect,
 ) (void | error) = {
-	return wrapvoid(_render_fill_rect(renderer, rect));
+	return wrapvoid(_SDL_RenderFillRect(renderer, rect));
 };