gg #

Description:

gg is V's simple graphics module. It is currently implemented using sokol, and makes easy creating apps that just need a way to draw simple 2D shapes, and to react to user's keyboard/mouse input.

Example:

module main

import gg
import gx

fn main() {
    mut context := gg.new_context(
        bg_color: gx.rgb(174, 198, 255)
        width: 600
        height: 400
        window_title: 'Polygons'
        frame_fn: frame
    )
    context.run()
}

fn frame(mut ctx gg.Context) {
    ctx.begin()
    ctx.draw_convex_poly([f32(100.0), 100.0, 200.0, 100.0, 300.0, 200.0, 200.0, 300.0, 100.0, 300.0],
        gx.blue)
    ctx.draw_poly_empty([f32(50.0), 50.0, 70.0, 60.0, 90.0, 80.0, 70.0, 110.0], gx.black)
    ctx.draw_triangle_filled(450, 142, 530, 280, 370, 280, gx.red)
    ctx.end()
}

fn dpi_scale() f32

dpi_scale returns the DPI scale coefficient for the screen.
Do not use for Android development, use Context.scale instead.

fn high_dpi() bool

high_dpi returns true if gg is running on a high DPI monitor or screen.

fn is_fullscreen() bool

is it fullscreen

fn new_context(cfg Config) &Context

new_context returns an initialized Context allocated on the heap.

fn screen_size() Size

screen_size returns the size of the active screen.

fn toggle_fullscreen()

toggle fullscreen

fn window_size() Size

window_size returns the Size of the active window.
Do not use for Android development, use Context.window_size() instead.

fn window_size_real_pixels() Size

window_size_real_pixels returns the Size of the active window without scale

type Color = gx.Color

type FNCb = fn (data voidptr)

type FNChar = fn (c u32, data voidptr)

type FNClick = fn (x f32, y f32, button MouseButton, data voidptr)

type FNEvent = fn (e &Event, data voidptr)

type FNFail = fn (msg string, data voidptr)

type FNKeyDown = fn (c KeyCode, m Modifier, data voidptr)

type FNKeyUp = fn (c KeyCode, m Modifier, data voidptr)

type FNMove = fn (x f32, y f32, data voidptr)

type FNUnClick = fn (x f32, y f32, button MouseButton, data voidptr)

fn (ft &FT) flush()

flush prepares the font for use.

type TouchPoint = C.sapp_touchpoint

fn C.WaitMessage()

enum ImageEffect {
// TODO(FireRedz): Add more effects
	alpha
	add
}

enum KeyCode {
	invalid = 0
	space = 32
	apostrophe = 39 //'
	comma = 44 //,
	minus = 45 //-
	period = 46 //.
	slash = 47 ///
	_0 = 48
	_1 = 49
	_2 = 50
	_3 = 51
	_4 = 52
	_5 = 53
	_6 = 54
	_7 = 55
	_8 = 56
	_9 = 57
	semicolon = 59 //;
	equal = 61 //=
	a = 65
	b = 66
	c = 67
	d = 68
	e = 69
	f = 70
	g = 71
	h = 72
	i = 73
	j = 74
	k = 75
	l = 76
	m = 77
	n = 78
	o = 79
	p = 80
	q = 81
	r = 82
	s = 83
	t = 84
	u = 85
	v = 86
	w = 87
	x = 88
	y = 89
	z = 90
	left_bracket = 91 //[
	backslash = 92 //\
	right_bracket = 93 //]
	grave_accent = 96 //`
	world_1 = 161 // non-us #1
	world_2 = 162 // non-us #2
	escape = 256
	enter = 257
	tab = 258
	backspace = 259
	insert = 260
	delete = 261
	right = 262
	left = 263
	down = 264
	up = 265
	page_up = 266
	page_down = 267
	home = 268
	end = 269
	caps_lock = 280
	scroll_lock = 281
	num_lock = 282
	print_screen = 283
	pause = 284
	f1 = 290
	f2 = 291
	f3 = 292
	f4 = 293
	f5 = 294
	f6 = 295
	f7 = 296
	f8 = 297
	f9 = 298
	f10 = 299
	f11 = 300
	f12 = 301
	f13 = 302
	f14 = 303
	f15 = 304
	f16 = 305
	f17 = 306
	f18 = 307
	f19 = 308
	f20 = 309
	f21 = 310
	f22 = 311
	f23 = 312
	f24 = 313
	f25 = 314
	kp_0 = 320
	kp_1 = 321
	kp_2 = 322
	kp_3 = 323
	kp_4 = 324
	kp_5 = 325
	kp_6 = 326
	kp_7 = 327
	kp_8 = 328
	kp_9 = 329
	kp_decimal = 330
	kp_divide = 331
	kp_multiply = 332
	kp_subtract = 333
	kp_add = 334
	kp_enter = 335
	kp_equal = 336
	left_shift = 340
	left_control = 341
	left_alt = 342
	left_super = 343
	right_shift = 344
	right_control = 345
	right_alt = 346
	right_super = 347
	menu = 348
}

enum Modifier {
	shift // (1<<0)
	ctrl // (1<<1)
	alt // (1<<2)
	super // (1<<3)
}

enum MouseButton {
	left = 0
	right = 1
	middle = 2
	invalid = 256
}

enum MouseButtons {
	left
	right
	middle
}

Note: unlike the MouseButton enum from above, the [flag]-ed enum here can have combined states, representing several pressed buttons at once.

enum PenLineType {
	solid
	dashed
	dotted
}

struct Config {
pub:
	width         int
	height        int
	use_ortho     bool // unused, still here just for backwards compatibility
	retina        bool
	resizable     bool
	user_data     voidptr
	font_size     int
	create_window bool
// window_user_ptr voidptr
	window_title      string
	borderless_window bool
	always_on_top     bool
	bg_color          gx.Color
	init_fn           FNCb   = unsafe { nil }
	frame_fn          FNCb   = unsafe { nil }
	native_frame_fn   FNCb   = unsafe { nil }
	cleanup_fn        FNCb   = unsafe { nil }
	fail_fn           FNFail = unsafe { nil }
//
	event_fn FNEvent = unsafe { nil }
	quit_fn  FNEvent = unsafe { nil }
//
	keydown_fn FNKeyDown = unsafe { nil }
	keyup_fn   FNKeyUp   = unsafe { nil }
	char_fn    FNChar    = unsafe { nil }
//
	move_fn    FNMove    = unsafe { nil }
	click_fn   FNClick   = unsafe { nil }
	unclick_fn FNUnClick = unsafe { nil }
	leave_fn   FNEvent   = unsafe { nil }
	enter_fn   FNEvent   = unsafe { nil }
	resized_fn FNEvent   = unsafe { nil }
	scroll_fn  FNEvent   = unsafe { nil }
// wait_events       bool // set this to true for UIs, to save power
	fullscreen    bool
	scale         f32 = 1.0
	sample_count  int
	swap_interval int = 1 // 1 = 60fps, 2 = 30fps etc. The preferred swap interval (ignored on some platforms)
// ved needs this
// init_text bool
	font_path             string
	custom_bold_font_path string
	ui_mode               bool // refreshes only on events to save CPU usage
// font bytes for embedding
	font_bytes_normal []u8
	font_bytes_bold   []u8
	font_bytes_mono   []u8
	font_bytes_italic []u8
	native_rendering  bool // Cocoa on macOS/iOS, GDI+ on Windows
// drag&drop
	enable_dragndrop             bool // enable file dropping (drag'n'drop), default is false
	max_dropped_files            int = 1 // max number of dropped files to process (default: 1)
	max_dropped_file_path_length int = 2048 // max length in bytes of a dropped UTF-8 file path (default: 2048)
}

struct Context {
mut:
	render_text bool = true
// a cache with all images created by the user. used for sokol image init and to save space
// (so that the user can store image ids, not entire Image objects)
	image_cache   []Image
	needs_refresh bool = true
	ticks         int // for ui mode only
pub:
	native_rendering bool
pub mut:
	scale       f32 = 1.0 // will get set to 2.0 for retina, will remain 1.0 for normal
	width       int
	height      int
	clear_pass  gfx.PassAction
	window      sapp.Desc
	timage_pip  sgl.Pipeline       [deprecated: 'Use `Context.pipeline.alpha` instead!']
	pipeline    &PipelineContainer = unsafe { nil }
	config      Config
	user_data   voidptr
	ft          &FT = unsafe { nil }
	font_inited bool
	ui_mode     bool // do not redraw everything 60 times/second, but only when the user requests
	frame       u64  // the current frame counted from the start of the application; always increasing
//
	mbtn_mask     u8
	mouse_buttons MouseButtons // typed version of mbtn_mask; easier to use for user programs
	mouse_pos_x   int
	mouse_pos_y   int
	mouse_dx      int
	mouse_dy      int
	scroll_x      int
	scroll_y      int
//
	key_modifiers     Modifier // the current key modifiers
	key_repeat        bool     // whether the pressed key was an autorepeated one
	pressed_keys      [key_code_max]bool // an array representing all currently pressed keys
	pressed_keys_edge [key_code_max]bool // true when the previous state of pressed_keys,
// *before* the current event was different
	fps FPSConfig
}

fn (ctx &Context) begin()

begin prepares the context for drawing.

fn (mut ctx Context) cache_image(img Image) int

cache_image caches the image img in memory for later reuse.
cache_image returns the cache index of the cached image.

See also: get_cached_image_by_idx See also: remove_cached_image_by_idx

fn (ctx &Context) create_image(file string) !Image

create_image creates an Image from file.

fn (mut ctx Context) create_image_from_byte_array(b []u8) !Image

create_image_from_byte_array creates an Image from the byte array b.

See also: create_image_from_memory

fn (mut ctx Context) create_image_from_memory(buf &u8, bufsize int) !Image

create_image_from_memory creates an Image from the memory buffer buf of size bufsize.

See also: create_image_from_byte_array

fn (mut ctx Context) create_image_with_size(file string, width int, height int) Image

create_image_with_size creates an Image from file in the given width x height dimension.

TODO copypasta

fn (ctx &Context) draw_arc(x f32, y f32, inner_radius f32, thickness f32, start_angle f32, end_angle f32, segments int, c gx.Color)

fn (ctx &Context) draw_arc_empty(x f32, y f32, inner_radius f32, thickness f32, start_angle f32, end_angle f32, segments int, c gx.Color)

draw_arc_empty draws the outline of an arc.
x,y defines the end point of the arc (center of the circle that the arc is part of).
inner_radius defines the radius of the arc (length from the center point where the arc is drawn).
thickness defines how wide the arc is drawn.
start_angle is the angle in radians at which the arc starts.
end_angle is the angle in radians at which the arc ends.
segments affects how smooth/round the arc is.
c is the color of the arc outline.

fn (ctx &Context) draw_arc_filled(x f32, y f32, inner_radius f32, thickness f32, start_angle f32, end_angle f32, segments int, c gx.Color)

draw_arc_filled draws a filled arc.
x,y defines the central point of the arc (center of the circle that the arc is part of).
inner_radius defines the radius of the arc (length from the center point where the arc is drawn).
thickness defines how wide the arc is drawn.
start_angle is the angle in radians at which the arc starts.
end_angle is the angle in radians at which the arc ends.
segments affects how smooth/round the arc is.
c is the fill color of the arc.

fn (ctx Context) draw_arc_line(x f32, y f32, radius f32, start_angle f32, end_angle f32, segments int, c gx.Color)

draw_arc_line draws a line arc.
x,y defines the end point of the arc (center of the circle that the arc is part of).
radius defines the radius of the arc (length from the center point where the arc is drawn).
start_angle is the angle in radians at which the arc starts.
end_angle is the angle in radians at which the arc ends.
segments affects how smooth/round the arc is.
c is the color of the arc/outline.

fn (ctx &Context) draw_circle(x f32, y f32, radius f32, c gx.Color)

fn (ctx &Context) draw_circle_empty(x f32, y f32, radius f32, c gx.Color)

draw_circle_empty draws the outline of a circle.
x,y defines the center of the circle.
radius defines the radius of the circle.
c is the color of the outline.

fn (ctx &Context) draw_circle_filled(x f32, y f32, radius f32, c gx.Color)

draw_circle_filled draws a filled circle.
x,y defines the center of the circle.
radius defines the radius of the circle.
c is the fill color.

fn (ctx &Context) draw_circle_line(x f32, y f32, radius int, segments int, c gx.Color)

draw_circle_line draws the outline of a circle with a specific number of segments.
x,y defines the center of the circle.
radius defines the radius of the circle.
segments affects how smooth/round the circle is.
c is the color of the outline.

fn (ctx &Context) draw_circle_with_segments(x f32, y f32, radius f32, segments int, c gx.Color)

draw_circle_with_segments draws a filled circle with a specific number of segments.
x,y defines the center of the circle.
radius defines the radius of the circle.
segments affects how smooth/round the circle is.
c is the fill color.

fn (ctx &Context) draw_convex_poly(points []f32, c gx.Color)

draw_convex_poly draws a convex polygon, given an array of points, and a color.
NOTE that the points must be given in clockwise winding order.
The contents of the points array should be x and y coordinate pairs.

fn (ctx &Context) draw_cubic_bezier(points []f32, c gx.Color)

draw_cubic_bezier draws a cubic Bézier curve, also known as a spline, from four points.
The four points is provided as one points array which contains a stream of point pairs (x and y coordinates).
Thus a cubic Bézier could be declared as: points := [x1, y1, control_x1, control_y1, control_x2, control_y2, x2, y2].
Please see draw_cubic_bezier_in_steps to control the amount of steps (segments) used to draw the curve.

fn (ctx &Context) draw_cubic_bezier_in_steps(points []f32, steps u32, c gx.Color)

draw_cubic_bezier_in_steps draws a cubic Bézier curve, also known as a spline, from four points.
The smoothness of the curve can be controlled with the steps parameter. steps determines how many iterations is taken to draw the curve.
The four points is provided as one points array which contains a stream of point pairs (x and y coordinates).
Thus a cubic Bézier could be declared as: points := [x1, y1, control_x1, control_y1, control_x2, control_y2, x2, y2].

fn (ctx &Context) draw_ellipse(x f32, y f32, rw f32, rh f32, c gx.Color)

fn (ctx &Context) draw_ellipse_empty(x f32, y f32, rw f32, rh f32, c gx.Color)

draw_ellipse_empty draws the outline of an ellipse.
x,y defines the center of the ellipse.
rw defines the width radius of the ellipse.
rh defines the height radius of the ellipse.
c is the color of the outline.

fn (ctx &Context) draw_ellipse_filled(x f32, y f32, rw f32, rh f32, c gx.Color)

draw_ellipse_filled draws an opaque elipse.
x,y defines the center of the ellipse.
rw defines the width radius of the ellipse.
rh defines the height radius of the ellipse.
c is the fill color.

fn (ctx &Context) draw_empty_arc(x f32, y f32, inner_radius f32, thickness f32, start_angle f32, end_angle f32, segments int, c gx.Color)

fn (ctx &Context) draw_empty_ellipse(x f32, y f32, rw f32, rh f32, c gx.Color)

fn (ctx &Context) draw_empty_poly(points []f32, c gx.Color)

fn (ctx &Context) draw_empty_rect(x f32, y f32, w f32, h f32, c gx.Color)

Draws the outline of a rectangle

fn (ctx &Context) draw_empty_rounded_rect(x f32, y f32, w f32, h f32, radius f32, c gx.Color)

fn (ctx &Context) draw_empty_slice(x f32, y f32, radius f32, start_angle f32, end_angle f32, segments int, c gx.Color)

fn (ctx &Context) draw_empty_square(x f32, y f32, s f32, c gx.Color)

Draws the outline of a square

fn (ctx &Context) draw_empty_triangle(x f32, y f32, x2 f32, y2 f32, x3 f32, y3 f32, c gx.Color)

Draws the outline of a triangle

fn (ctx &Context) draw_image(x f32, y f32, width f32, height f32, img_ &Image)

draw_image draws the provided image onto the screen.

fn (ctx &Context) draw_image_3d(x f32, y f32, z f32, width f32, height f32, img_ &Image)

draw_image_3d draws an image with a z depth

fn (ctx &Context) draw_image_by_id(x f32, y f32, width f32, height f32, id int)

draw_image_by_id draws an image by its id

fn (ctx &Context) draw_image_flipped(x f32, y f32, width f32, height f32, img_ &Image)

draw_image_flipped draws the provided image flipped horizontally (use draw_image_with_config to flip vertically)

fn (ctx &Context) draw_image_part(img_rect Rect, part_rect Rect, img_ &Image)

Draw part of an image using uv coordinates img_rect is the size and position (in pixels on screen) of the displayed rectangle (ie the draw_image args) part_rect is the size and position (in absolute pixels in the image) of the wanted part eg. On a 600600 context, to display only the first 400400 pixels of a 2000*2000 image on the entire context surface, call : draw_image_part(Rect{0, 0, 600, 600}, Rect{0, 0, 400, 400}, img)

fn (ctx &Context) draw_image_with_config(config DrawImageConfig)

draw_image_with_config takes in a config that details how the provided image should be drawn onto the screen

fn (ctx &Context) draw_line(x f32, y f32, x2 f32, y2 f32, c gx.Color)

draw_line draws a line between the points x,y and x2,y2 in color c.

fn (ctx &Context) draw_line_with_config(x f32, y f32, x2 f32, y2 f32, config PenConfig)

draw_line_with_config draws a line between the points x,y and x2,y2 using PenConfig.

fn (ctx &Context) draw_pixel(x f32, y f32, c gx.Color)

draw_pixel draws one pixel on the screen.

NOTE calling this function frequently is very inefficient, for drawing shapes it's recommended to draw whole primitives with functions like draw_rect_empty or draw_triangle_empty etc.

fn (ctx &Context) draw_pixels(points []f32, c gx.Color)

draw_pixels draws pixels from an array of points [x, y, x2, y2, etc...]

NOTE calling this function frequently is very inefficient, for drawing shapes it's recommended to draw whole primitives with functions like draw_rect_empty or draw_triangle_empty etc.

fn (ctx &Context) draw_poly_empty(points []f32, c gx.Color)

draw_poly_empty draws the outline of a polygon, given an array of points, and a color.
NOTE that the points must be given in clockwise winding order.

fn (ctx &Context) draw_polygon_filled(x f32, y f32, size f32, edges int, rotation f32, c gx.Color)

draw_polygon_filled draws a filled polygon.
x,y defines the center of the polygon.
size defines the size of the polygon.
edges defines number of edges in the polygon.
rotation defines rotation of the polygon.
c is the fill color.

fn (ctx &Context) draw_rect(x f32, y f32, w f32, h f32, c gx.Color)

TODO: Fix alpha

fn (ctx &Context) draw_rect_empty(x f32, y f32, w f32, h f32, c gx.Color)

draw_rect_empty draws the outline of a rectangle.
x,y is the top-left corner of the rectangle.
w is the width, h is the height and c is the color of the outline.

fn (ctx &Context) draw_rect_filled(x f32, y f32, w f32, h f32, c gx.Color)

draw_rect_filled draws a filled rectangle.
x,y is the top-left corner of the rectangle.
w is the width, h is the height and c is the color of the fill.

fn (ctx &Context) draw_rounded_rect(x f32, y f32, w f32, h f32, radius f32, c gx.Color)

fn (ctx &Context) draw_rounded_rect_empty(x f32, y f32, w f32, h f32, radius f32, c gx.Color)

draw_rounded_rect_empty draws the outline of a rounded rectangle with a thickness of 1 px.
x,y is the top-left corner of the rectangle.
w is the width, h is the height.
radius is the radius of the corner-rounding in pixels.
c is the color of the outline.

fn (ctx &Context) draw_rounded_rect_filled(x f32, y f32, w f32, h f32, radius f32, c gx.Color)

draw_rounded_rect_filled draws a filled rounded rectangle.
x,y is the top-left corner of the rectangle.
w is the width, h is the height .
radius is the radius of the corner-rounding in pixels.
c is the color of the filled.

fn (ctx &Context) draw_slice(x f32, y f32, radius f32, start_angle f32, end_angle f32, segments int, c gx.Color)

fn (ctx &Context) draw_slice_empty(x f32, y f32, radius f32, start_angle f32, end_angle f32, segments int, c gx.Color)

draw_slice_empty draws the outline of a circle slice/pie

fn (ctx &Context) draw_slice_filled(x f32, y f32, radius f32, start_angle f32, end_angle f32, segments int, c gx.Color)

draw_slice_filled draws a filled circle slice/pie x,y defines the end point of the slice (center of the circle that the slice is part of).
radius defines the radius ("length") of the slice.
start_angle is the angle in radians at which the slice starts.
end_angle is the angle in radians at which the slice ends.
segments affects how smooth/round the slice is.
c is the fill color.

fn (ctx &Context) draw_square(x f32, y f32, s f32, c gx.Color)

Draws a filled square

fn (ctx &Context) draw_square_empty(x f32, y f32, s f32, c gx.Color)

draw_square_empty draws the outline of a square.
x,y is the top-left corner of the square.
s is the length of each side of the square.
c is the color of the outline.

fn (ctx &Context) draw_square_filled(x f32, y f32, s f32, c gx.Color)

draw_square_filled draws a filled square.
x,y is the top-left corner of the square.
s is the length of each side of the square.
c is the fill color.

fn (ctx &Context) draw_text(x int, y int, text_ string, cfg gx.TextCfg)

draw_text draws the string in text_ starting at top-left position x,y.
Text settings can be provided with cfg.

fn (ctx &Context) draw_text_def(x int, y int, text string)

draw_text draws the string in text_ starting at top-left position x,y using default text settings.

fn (ctx &Context) draw_text_default(x int, y int, text string)

default draw_text (draw_text_def but without set_text_cfg)

fn (ctx &Context) draw_triangle(x f32, y f32, x2 f32, y2 f32, x3 f32, y3 f32, c gx.Color)

Draws a filled triangle

fn (ctx &Context) draw_triangle_empty(x f32, y f32, x2 f32, y2 f32, x3 f32, y3 f32, c gx.Color)

draw_triangle_empty draws the outline of a triangle.
x,y defines the first point x2,y2 defines the second point x3,y3 defines the third point c is the color of the outline.

fn (ctx &Context) draw_triangle_filled(x f32, y f32, x2 f32, y2 f32, x3 f32, y3 f32, c gx.Color)

draw_triangle_filled draws a filled triangle.
x,y defines the first point x2,y2 defines the second point x3,y3 defines the third point c is the color of the outline.

fn (ctx &Context) end()

end finishes drawing for the context.

fn (mut ctx Context) get_cached_image_by_idx(image_idx int) &Image

get_cached_image_by_idx returns a cached Image identified by image_idx.

See also: cache_image See also: remove_cached_image_by_idx

fn (ctx &Context) has_text_style() bool

fn (mut ctx Context) new_streaming_image(w int, h int, channels int, sicfg StreamingImageConfig) int

new_streaming_image returns a cached image_idx of a special image, that can be updated each frame by calling: gg.update_pixel_data(image_idx, buf) ... where buf is a pointer to the actual pixel data for the image.
Note: you still need to call app.gg.draw_image after that, to actually draw it.

fn (ctx &Context) quit()

quit closes the context window and exits the event loop for it

fn (mut ctx Context) record_frame()

record_frame records the current frame to a file.
record_frame acts according to settings specified in gg.recorder_settings.

fn (mut ctx Context) refresh_ui()

refresh_ui requests a complete re-draw of the window contents.

fn (mut ctx Context) remove_cached_image_by_idx(image_idx int)

remove_cached_image_by_idx removes an Image identified by image_idx from the image cache.

See also: cache_image See also: get_cached_image_by_idx

fn (mut ctx Context) resize(width int, height int)

Resize the context's Window

fn (mut ctx Context) run()

run starts the main loop of the context.

fn (ctx &Context) scissor_rect(x int, y int, w int, h int)

required for ui.DrawDevice interface (with &gg.Context as an instance)

fn (mut ctx Context) set_bg_color(c gx.Color)

set_bg_color sets the color of the window background to c.

fn (ctx &Context) set_cfg(cfg gx.TextCfg)

set_cfg sets the current text configuration

fn (ctx &Context) set_pixel(x f32, y f32, c gx.Color)

Sets a pixel

fn (ctx &Context) set_pixels(points []f32, c gx.Color)

fn (ctx &Context) set_text_cfg(cfg gx.TextCfg)

set_text_cfg sets the current text configuration

fn (ctx &Context) set_text_style(font_name string, font_path string, size int, color gx.Color, align int, vertical_align int)

fn (ctx &Context) show_fps()

fn (ctx &Context) text_height(s string) int

text_height returns the height of the string s in pixels.

fn (ctx &Context) text_size(s string) (int, int)

text_size returns the width and height of the string s in pixels.

fn (ctx &Context) text_width(s string) int

text_width returns the width of the string s in pixels.

fn (mut ctx Context) update_pixel_data(cached_image_idx int, buf &u8)

update_pixel_data is a helper for working with image streams (i.e. images, that are updated dynamically by the CPU on each frame)

fn (ctx Context) window_size() Size

window_size returns the current dimensions of the window.

struct DrawImageConfig {
pub:
	flip_x    bool
	flip_y    bool
	img       &Image = unsafe { nil }
	img_id    int
	img_rect  Rect // defines the size and position on image when rendering to the screen
	part_rect Rect // defines the size and position of part of the image to use when rendering
	rotate    int  // amount to rotate the image in degrees
	z         f32
	color     gx.Color    = gx.white
	effect    ImageEffect = .alpha
}

DrawImageConfig struct defines the various options that can be used to draw an image onto the screen

struct Event {
pub mut:
	frame_count        u64
	typ                sapp.EventType
	key_code           KeyCode
	char_code          u32
	key_repeat         bool
	modifiers          u32
	mouse_button       MouseButton
	mouse_x            f32
	mouse_y            f32
	mouse_dx           f32
	mouse_dy           f32
	scroll_x           f32
	scroll_y           f32
	num_touches        int
	touches            [8]TouchPoint
	window_width       int
	window_height      int
	framebuffer_width  int
	framebuffer_height int
}

struct FPSConfig {
pub mut:
	x           int
	y           int
	width       int
	height      int
	show        bool // do not show by default, use `-d show_fps` or set it manually in your app to override with: `app.gg.fps.show = true`
	text_config gx.TextCfg = gx.TextCfg{
		color: gx.yellow
		size: 20
		align: .center
		vertical_align: .middle
	}
	background_color gx.Color = gx.Color{
		r: 0
		g: 0
		b: 0
		a: 128
	}
}

struct Image {
pub mut:
	id          int
	width       int
	height      int
	nr_channels int
	ok          bool
	data        voidptr
	ext         string
	simg_ok     bool
	simg        gfx.Image
	path        string
}

Image holds the fileds and data needed to represent a bitmap/pixel based image in memory.

fn (mut img Image) init_sokol_image() &Image

init_sokol_image initializes this Image for use with the sokol graphical backend system.

fn (mut img Image) update_pixel_data(buf &u8)

update_pixel_data updates the sokol specific pixel data associated with this Image.

struct PenConfig {
	color     gx.Color
	line_type PenLineType = .solid
	thickness int = 1
}

struct PipelineContainer {
pub mut:
	alpha sgl.Pipeline
	add   sgl.Pipeline
}

struct Rect {
pub:
	x      f32
	y      f32
	width  f32
	height f32
}

Rect represents a rectangular shape in gg.

struct Size {
pub mut:
	width  int
	height int
}

struct SSRecorderSettings {
pub mut:
	stop_at_frame     i64 = -1
	screenshot_frames []u64
	screenshot_folder string
	screenshot_prefix string
}

struct StreamingImageConfig {
	pixel_format gfx.PixelFormat = .rgba8
	wrap_u       gfx.Wrap        = .clamp_to_edge
	wrap_v       gfx.Wrap        = .clamp_to_edge
	min_filter   gfx.Filter      = .linear
	mag_filter   gfx.Filter      = .linear
	num_mipmaps  int = 1
	num_slices   int = 1
}