Module gg stdlib

gg
Version:
0.3.3
License:
MIT
Dependencies from vmod:
0
Imports:
12
Imported by:
7
Repository:
OS-specific
Show selected OS-specific symbols.
Backend-specific
Show selected Backend-specific symbols.

Dependencies defined in v.mod

This section is empty.

Imported by

Overview

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()
}

Aliases

#type TouchPoint

type TouchPoint = C.sapp_touchpoint

#type Color

type Color = gx.Color

Constants

This section is empty.

Sum types

This section is empty.

Functions

#fn android_dpi_scale

Termux
fn android_dpi_scale() f32

android_dpi_scale returns the scale factor of the device.

#fn dpi_scale

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

fn high_dpi() bool

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

#fn is_fullscreen

fn is_fullscreen() bool

is it fullscreen

#fn screen_size

fn screen_size() Size

screen_size returns the size of the active screen.

#fn toggle_fullscreen

fn toggle_fullscreen()

toggle fullscreen

#fn window_size

JavaScript
fn window_size() Size

#fn window_size

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

fn window_size_real_pixels() Size

window_size_real_pixels returns the Size of the active window without scale

Structs

#struct Event

pub 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 Config

pub 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 PipelineContainer

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

#fn (&PipelineContainer) init_pipeline

fn (mut container &PipelineContainer) init_pipeline()

#struct Context

heap
pub 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 new_context

fn new_context(cfg Config) &Context

new_context returns an initialized Context allocated on the heap.

#fn (&Context) draw_pixel

inline
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 (&Context) draw_pixels

direct_array_accessinline
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 (&Context) draw_line

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 (&Context) draw_line_with_config

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 (&Context) draw_poly_empty

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 (&Context) draw_convex_poly

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 (&Context) draw_rect_empty

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 (&Context) draw_rect_filled

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 (&Context) draw_rounded_rect_empty

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 (&Context) draw_rounded_rect_filled

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 (&Context) draw_triangle_empty

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 (&Context) draw_triangle_filled

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 (&Context) draw_square_empty

inline
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 (&Context) draw_square_filled

inline
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 (&Context) draw_circle_empty

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 (&Context) draw_circle_filled

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 (&Context) draw_polygon_filled

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 (&Context) draw_circle_with_segments

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 (&Context) draw_circle_line

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 (&Context) draw_slice_empty

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 (&Context) draw_slice_filled

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 (Context) draw_arc_line

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 (&Context) draw_arc_empty

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 (&Context) draw_arc_filled

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 (&Context) draw_ellipse_empty

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 (&Context) draw_ellipse_filled

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 (&Context) draw_cubic_bezier

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 (&Context) draw_cubic_bezier_in_steps

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 (&Context) set_pixel

deprecated:use draw_pixel() instead
fn (ctx &Context) set_pixel(x f32, y f32, c gx.Color)

Sets a pixel

#fn (&Context) set_pixels

deprecated:use draw_pixels() instead
fn (ctx &Context) set_pixels(points []f32, c gx.Color)

#fn (&Context) draw_empty_poly

deprecated:use draw_poly_empty() instead
fn (ctx &Context) draw_empty_poly(points []f32, c gx.Color)

#fn (&Context) draw_rect

deprecated:use draw_rect_filled() instead
fn (ctx &Context) draw_rect(x f32, y f32, w f32, h f32, c gx.Color)

TODO: Fix alpha

#fn (&Context) draw_empty_rect

deprecated:use draw_rect_empty() instead
fn (ctx &Context) draw_empty_rect(x f32, y f32, w f32, h f32, c gx.Color)

Draws the outline of a rectangle

#fn (&Context) draw_empty_rounded_rect

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

#fn (&Context) draw_rounded_rect

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

#fn (&Context) draw_empty_triangle

deprecated:use draw_triangle_empty() instead
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 (&Context) draw_triangle

deprecated:use draw_triangle_filled() instead
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 (&Context) draw_empty_square

deprecated:use draw_square_empty() instead
fn (ctx &Context) draw_empty_square(x f32, y f32, s f32, c gx.Color)

Draws the outline of a square

#fn (&Context) draw_square

deprecated:use draw_square_filled() instead
fn (ctx &Context) draw_square(x f32, y f32, s f32, c gx.Color)

Draws a filled square

#fn (&Context) draw_circle

deprecated:use draw_circle_filled() instead
fn (ctx &Context) draw_circle(x f32, y f32, radius f32, c gx.Color)

#fn (&Context) draw_empty_slice

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

#fn (&Context) draw_slice

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

#fn (&Context) draw_empty_arc

deprecated:use draw_arc_empty() instead
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 (&Context) draw_arc

deprecated:use draw_arc_filled() instead
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 (&Context) draw_empty_ellipse

deprecated:use draw_ellipse_empty() instead
fn (ctx &Context) draw_empty_ellipse(x f32, y f32, rw f32, rh f32, c gx.Color)

#fn (&Context) draw_ellipse

deprecated:use draw_ellipse_filled() instead
fn (ctx &Context) draw_ellipse(x f32, y f32, rw f32, rh f32, c gx.Color)

#fn (&Context) run

fn (mut ctx &Context) run()

run starts the main loop of the context.

#fn (&Context) quit

fn (ctx &Context) quit()

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

#fn (&Context) set_bg_color

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

set_bg_color sets the color of the window background to c.

#fn (&Context) resize

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

Resize the context's Window

#fn (&Context) refresh_ui

fn (mut ctx &Context) refresh_ui()

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

#fn (&Context) begin

fn (ctx &Context) begin()

begin prepares the context for drawing.

#fn (&Context) end

fn (ctx &Context) end()

end finishes drawing for the context.

#fn (&Context) show_fps

fn (ctx &Context) show_fps()

#fn (&Context) set_scale

fn (mut ctx &Context) set_scale()

#fn (&Context) window_size

fn (ctx &Context) window_size() Size

window_size returns the current dimensions of the window.

#fn (&Context) handle_mouse_event

JavaScript
fn (mut g &Context) handle_mouse_event(event JS.MouseEvent, typ DOMEventType) Event

#fn (&Context) handle_keyboard_event

JavaScript
fn (mut g &Context) handle_keyboard_event(event JS.KeyboardEvent, typ DOMEventType) Event

#fn (&Context) scissor_rect

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 (&Context) has_text_style

fn (ctx &Context) has_text_style() bool

#fn (&Context) set_text_style

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

#fn (&Context) draw_text_default

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

default draw_text (draw_text_def but without set_text_cfg)

#fn (&Context) create_image

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

create_image creates an Image from file.

#fn (&Context) draw_image

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 (&Context) new_streaming_image

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 (&Context) update_pixel_data

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 (&Context) create_image_with_size

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 (&Context) 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 (&Context) create_image_from_byte_array

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 (&Context) draw_image_with_config

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 (&Context) cache_image

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 (&Context) get_cached_image_by_idx

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 (&Context) remove_cached_image_by_idx

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 (&Context) draw_image_part

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 (&Context) draw_image_flipped

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 (&Context) draw_image_by_id

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 (&Context) draw_image_3d

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 (&Context) record_frame

gg_record ?
fn (mut ctx &Context) record_frame()

record_frame records the current frame to a file.

record_frame acts according to settings specified in recorder_settings.

#fn (&Context) set_text_cfg

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

set_text_cfg sets the current text configuration

#fn (&Context) set_cfg

deprecated:use set_text_cfg() instead
fn (ctx &Context) set_cfg(cfg gx.TextCfg)

set_cfg sets the current text configuration

#fn (&Context) draw_text

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 (&Context) draw_text_def

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 (&Context) text_width

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

text_width returns the width of the string s in pixels.

#fn (&Context) text_height

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

text_height returns the height of the string s in pixels.

#fn (&Context) text_size

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

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

#struct FPSConfig

pub 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 PenConfig

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

#struct Size

pub struct Size {
pub mut:
	width  int
	height int
}

#struct Image

heap
pub 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 (&Image) init_sokol_image

fn (mut img &Image) init_sokol_image() &Image

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

#fn (&Image) update_pixel_data

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

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

#struct StreamingImageConfig

pub 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
}

#struct DrawImageConfig

pub 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 Rect

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

Rect represents a rectangular shape in gg.

#struct SSRecorderSettings

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

Interfaces

This section is empty.

Enums

#enum MouseButton

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

#enum MouseButtons

flag
pub enum MouseButtons {
	left
	right
	middle
}

#enum Modifier

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

#enum PenLineType

pub enum PenLineType {
	solid
	dashed
	dotted
}

#enum KeyCode

pub 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 DOMEventType

JavaScript
pub enum DOMEventType {
	invalid
	key_down
	key_up
	char
	mouse_down
	mouse_up
	mouse_scroll
	mouse_move
	mouse_enter
	mouse_leave
	touches_began
	touches_moved
	touches_ended
	touches_cancelled
	resized
	iconified
	restored
	focused
	unfocused
	suspended
	resumed
	update_cursor
	quit_requested
	clipboard_pasted
	files_droped
	num
}

#enum DOMModifier

JavaScript
pub enum DOMModifier {
	shift = 1 //(1<<0)
	ctrl = 2 //(1<<1)
	alt = 4 //(1<<2)
	super = 8 //(1<<3)
	lmb = 0x100
	rmb = 0x200
	mmb = 0x400
}

#enum DOMKeyCode

JavaScript
pub enum DOMKeyCode {
	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 ImageEffect

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