android_api_level :: enum u32 {
	Nougat          = 24, 
	Nougat_MR1      = 25, 
	Oreo            = 26, 
	Oreo_MR1        = 27, 
	Pie             = 28, 
	Q               = 29, 
	R               = 30, 
	S               = 31, 
	S_V2            = 32, 
	Tiramisu        = 33, 
	UpsideDownCake  = 34, 
	VanillaIceCream = 35, 
	Baklava         = 36, 
	Unknown         = 0, 
}

android_platform_version ¶
Source

android_platform_version :: struct {
	api_level: android_api_level,
}

base_resource ¶
Source

base_resource :: struct {
	g_uniform_indices: [4]vulkan.DeviceSize,
	idx:               rawptr,
	// unused uniform buffer
	mem_buffer:        MEM_BUFFER,
	completed:         bool,
}

buffer_type ¶
Source

buffer_type :: enum int {
	VERTEX, 
	INDEX, 
	UNIFORM, 
	STORAGE, 
	__STAGING, 
}

button_idx ¶
Source

button_idx :: enum int {
	LEFT   = 0, 
	MIDDLE = 1, 
	RIGHT  = 2, 
}

camera ¶
Source

camera :: struct {
	using _: __matrix_in,
}

Camera structure for view matrix management

Contains the view matrix and uniform buffer for rendering

Related Procedures With Parameters

Related Procedures With Returns

def_camera

command_buffer ¶
Source

command_buffer :: struct #packed {
	__handle: vulkan.CommandBuffer,
}

Related Procedures With Parameters

descriptor_pool_mem ¶
Source

descriptor_pool_mem :: struct {
	pool: vulkan.DescriptorPool,
	cnt:  u32,
}

descriptor_pool_size ¶
Source

descriptor_pool_size :: struct {
	type: descriptor_type,
	cnt:  u32,
}

descriptor_set ¶
Source

descriptor_set :: struct($N: int) {
	… // See source for fields
}

descriptor_set_layout_binding ¶
Source

descriptor_set_layout_binding :: vulkan.DescriptorSetLayoutBinding

descriptor_type ¶
Source

descriptor_type :: enum int {
	SAMPLER,         // vk.DescriptorType.COMBINED_IMAGE_SAMPLER
	UNIFORM_DYNAMIC, // vk.DescriptorType.UNIFORM_BUFFER_DYNAMIC
	UNIFORM,         // vk.DescriptorType.UNIFORM_BUFFER
	STORAGE, 
	STORAGE_IMAGE,   // TODO (xfitgd)
}

general_input_buttons ¶
Source

general_input_buttons :: struct #packed {
	a:              bool,
	b:              bool,
	x:              bool,
	y:              bool,
	dpad_up:        bool,
	dpad_down:      bool,
	dpad_left:      bool,
	dpad_right:     bool,
	start:          bool,
	back:           bool,
	left_thumb:     bool,
	right_thumb:    bool,
	left_shoulder:  bool,
	right_shoulder: bool,
	volume_up:      bool,
	volume_down:    bool,
}

general_input_state ¶
Source

general_input_state :: struct {
	handle:        rawptr,
	left_thumb:    [2]f32,
	right_thumb:   [2]f32,
	left_trigger:  f32,
	right_trigger: f32,
	buttons:       general_input_buttons,
}

graphics_size ¶
Source

graphics_size :: vulkan.DeviceSize

Related Procedures With Parameters

i_descriptor_set ¶
Source

i_descriptor_set :: struct {
	layout:        vulkan.DescriptorSetLayout,
	// / created inside update_descriptor_set call
	__set:         vulkan.DescriptorSet,
	size:          []descriptor_pool_size,
	bindings:      []u32,
	num_resources: u32,
}

Related Procedures With Parameters

icon_image ¶
Source

icon_image :: glfw_bindings.Image

image ¶
Source

image :: struct {
	using _: itransform_object,
	src: ^texture,
}

Image object structure for rendering textures

Extends iobject with texture source data

Related Procedures With Parameters

Procedures Through `using` From itransform_object

Procedures Through `using` From iobject

iobject ¶
Source

iobject :: struct {
	actual_type: typeid,
	vtable:      ^iobject_vtable,
}

Base object interface structure for all renderable objects

Contains vtable for polymorphic behavior

Related Procedures With Parameters

Related Procedures With Returns

layer_get_object

iobject_vtable ¶
Source

iobject_vtable :: struct {
	draw:   proc(self: ^iobject, cmd: command_buffer, viewport: ^viewport),
	deinit: proc(self: ^iobject),
	update: proc(self: ^iobject),
	size:   proc(self: ^iobject),
}

Related Procedures With Parameters

itransform_object ¶
Source

itransform_object :: struct {
	using _:         iobject,
	using _:         __matrix_in,
	set:             descriptor_set($N=2),
	color_transform: ^color_transform,
}

Transformable object interface structure for all renderable objects

Contains transformation matrix, descriptor set for polymorphic behavior

Related Procedures With Parameters

Procedures Through `using` From iobject

key_code ¶
Source

key_code :: enum i32 {
	KEY_SPACE         = 32, 
	KEY_APOSTROPHE    = 39,  // '
	KEY_COMMA         = 44,  // ,
	KEY_MINUS         = 45,  // -
	KEY_PERIOD        = 46,  // .
	KEY_SLASH         = 47,  // /
	KEY_SEMICOLON     = 59,  // ;
	KEY_EQUAL         = 61,  // =
	KEY_LEFT_BRACKET  = 91,  // [
	KEY_BACKSLASH     = 92,  // \
	KEY_RIGHT_BRACKET = 93,  // ]
	KEY_GRAVE_ACCENT  = 96,  // `
	KEY_WORLD_1       = 161, // non-US #1
	KEY_WORLD_2       = 162, // non-US #2
	// Alphanumeric characters 
	KEY_0             = 48, 
	KEY_1             = 49, 
	KEY_2             = 50, 
	KEY_3             = 51, 
	KEY_4             = 52, 
	KEY_5             = 53, 
	KEY_6             = 54, 
	KEY_7             = 55, 
	KEY_8             = 56, 
	KEY_9             = 57, 
	KEY_A             = 65, 
	KEY_B             = 66, 
	KEY_C             = 67, 
	KEY_D             = 68, 
	KEY_E             = 69, 
	KEY_F             = 70, 
	KEY_G             = 71, 
	KEY_H             = 72, 
	KEY_I             = 73, 
	KEY_J             = 74, 
	KEY_K             = 75, 
	KEY_L             = 76, 
	KEY_M             = 77, 
	KEY_N             = 78, 
	KEY_O             = 79, 
	KEY_P             = 80, 
	KEY_Q             = 81, 
	KEY_R             = 82, 
	KEY_S             = 83, 
	KEY_T             = 84, 
	KEY_U             = 85, 
	KEY_V             = 86, 
	KEY_W             = 87, 
	KEY_X             = 88, 
	KEY_Y             = 89, 
	KEY_Z             = 90, 
	// Function keys 
	KEY_ESCAPE        = 256, 
	KEY_ENTER         = 257, 
	KEY_TAB           = 258, 
	KEY_BACKSPACE     = 259, 
	KEY_INSERT        = 260, 
	KEY_DELETE        = 261, 
	KEY_RIGHT         = 262, 
	KEY_LEFT          = 263, 
	KEY_DOWN          = 264, 
	KEY_UP            = 265, 
	KEY_PAGE_UP       = 266, 
	KEY_PAGE_DOWN     = 267, 
	KEY_HOME          = 268, 
	KEY_END           = 269, 
	KEY_CAPS_LOCK     = 280, 
	KEY_SCROLL_LOCK   = 281, 
	KEY_NUM_LOCK      = 282, 
	KEY_PRINT_SCREEN  = 283, 
	KEY_PAUSE         = 284, 
	// Function keys 
	KEY_F1            = 290, 
	KEY_F2            = 291, 
	KEY_F3            = 292, 
	KEY_F4            = 293, 
	KEY_F5            = 294, 
	KEY_F6            = 295, 
	KEY_F7            = 296, 
	KEY_F8            = 297, 
	KEY_F9            = 298, 
	KEY_F10           = 299, 
	KEY_F11           = 300, 
	KEY_F12           = 301, 
	KEY_F13           = 302, 
	KEY_F14           = 303, 
	KEY_F15           = 304, 
	KEY_F16           = 305, 
	KEY_F17           = 306, 
	KEY_F18           = 307, 
	KEY_F19           = 308, 
	KEY_F20           = 309, 
	KEY_F21           = 310, 
	KEY_F22           = 311, 
	KEY_F23           = 312, 
	KEY_F24           = 313, 
	KEY_F25           = 314, 
	// Keypad numbers 
	KEY_NUM_0         = 320, 
	KEY_NUM_1         = 321, 
	KEY_NUM_2         = 322, 
	KEY_NUM_3         = 323, 
	KEY_NUM_4         = 324, 
	KEY_NUM_5         = 325, 
	KEY_NUM_6         = 326, 
	KEY_NUM_7         = 327, 
	KEY_NUM_8         = 328, 
	KEY_NUM_9         = 329, 
	// Keypad named function keys 
	KEY_NUM_DOT       = 330, 
	KEY_NUM_DIVIDE    = 331, 
	KEY_NUM_MULTIPLY  = 332, 
	KEY_NUM_SUBTRACT  = 333, 
	KEY_NUM_ADD       = 334, 
	KEY_NUM_ENTER     = 335, 
	KEY_NUM_EQUAL     = 336, 
	// Modifier keys 
	KEY_LEFT_SHIFT    = 340, 
	KEY_LEFT_CONTROL  = 341, 
	KEY_LEFT_ALT      = 342, 
	KEY_LEFT_SUPER    = 343, 
	KEY_RIGHT_SHIFT   = 344, 
	KEY_RIGHT_CONTROL = 345, 
	KEY_RIGHT_ALT     = 346, 
	KEY_RIGHT_SUPER   = 347, 
	KEY_MENU          = 348, 
}

layer ¶
Source

layer :: struct {
	scene:              ^[dynamic]^iobject,
	cmd:                [2]command_buffer,
	cmd_pool:           vulkan.CommandPool,
	creation_allocator: runtime.Allocator,
	visible:            bool,
}

Render command structure for managing render objects

Manages a collection of objects to be rendered and their command buffers

Related Procedures With Parameters

Related Procedures With Returns

layer_init

linux_platform_version ¶
Source

linux_platform_version :: struct {
	sys_name:  string,
	node_name: string,
	release:   string,
	version:   string,
	machine:   string,
}

Related Procedures With Returns

get_platform_version

object_draw_type ¶
Source

object_draw_type :: enum int {
	Draw, 
	DrawIndexed, 
}

object_pipeline ¶
Source

object_pipeline :: struct {
	__pipeline:               vulkan.Pipeline,
	__pipeline_layout:        vulkan.PipelineLayout,
	__descriptor_set_layouts: []vulkan.DescriptorSetLayout,
	draw_method:              object_draw_method,
	allocator:                runtime.Allocator,
}

Related Procedures With Parameters

Related Procedures With Returns

p_descriptor_set ¶
Source

p_descriptor_set :: struct {
	using _:     i_descriptor_set,
	__resources: [1]union_resource,
}

Procedures Through `using` From i_descriptor_set

projection ¶
Source

projection :: struct {
	using _:             __matrix_in,
	ortho_canvas_width:  f32,
	// canvas width for ortho projection (if 0, not set; if set, projection_update_ortho_window is called when window size changes)
	ortho_canvas_height: f32,
}

Projection structure for projection matrix management

Contains the projection matrix and uniform buffer for rendering

Related Procedures With Parameters

Related Procedures With Returns

def_projection

resource_range ¶
Source

resource_range :: rawptr

Related Procedures With Parameters

resource_usage ¶
Source

resource_usage :: enum int {
	GPU, 
	CPU, 
}

Related Procedures With Parameters

screen_orientation ¶
Source

screen_orientation :: enum int {
	Unknown, 
	Landscape90, 
	Landscape270, 
	Vertical180, 
	Vertical360, 
}

shader_code ¶
Source

shader_code :: union {
	[]u8, 
	string, 
}

texture ¶
Source

texture :: struct {
	set:        descriptor_set($N=1),
	sampler:    vulkan.Sampler,
	pixel_data: []u8,
	width:      u32,
	height:     u32,
}

Related Procedures With Parameters

texture_array ¶
Source

texture_array :: struct {
	using _: texture,
	count: u32,
}

Related Procedures With Parameters

Procedures Through `using` From texture

texture_create_option ¶
Source

texture_create_option :: struct {
	len:            u32,
	width:          u32,
	height:         u32,
	type:           texture_type,
	texture_usage:  bit_set[texture_usage],
	resource_usage: resource_usage,
	format:         texture_fmt,
	samples:        u8,
	single:         bool,
	use_gcpu_mem:   bool,
}

Related Procedures With Parameters

buffer_resource_create_texture

texture_fmt ¶
Source

texture_fmt :: enum int {
	DefaultColor, 
	DefaultDepth, 
	R8G8B8A8Unorm, 
	B8G8R8A8Unorm, 
	// B8G8R8A8Srgb,
	// R8G8B8A8Srgb,
	D24UnormS8Uint, 
	D32SfloatS8Uint, 
	D16UnormS8Uint, 
	R8Unorm, 
}

Related Procedures With Parameters

texture_resource ¶
Source

texture_resource :: struct {
	using _:    base_resource,
	self:       ^texture_resource,
	img_view:   vulkan.ImageView,
	sampler:    vulkan.Sampler,
	option:     texture_create_option,
	__resource: vulkan.Image,
}

texture_type ¶
Source

texture_type :: enum int {
	TEX2D, 
}

texture_usage ¶
Source

texture_usage :: enum int {
	IMAGE_RESOURCE, 
	FRAME_BUFFER, 
	__INPUT_ATTACHMENT, 
	__TRANSIENT_ATTACHMENT, 
	__STORAGE_IMAGE, 
}

texture_usages ¶
Source

texture_usages :: bit_set[texture_usage]

tile_texture_array ¶
Source

tile_texture_array :: struct {
	using _: texture,
	count: u32,
}

Procedures Through `using` From texture

union_resource ¶
Source

union_resource :: union {
	^buffer_resource, 
	^texture_resource, 
}

Related Procedures With Returns

vertex_input_attribute_description ¶
Source

vertex_input_attribute_description :: vulkan.VertexInputAttributeDescription

vertex_input_binding_description ¶
Source

vertex_input_binding_description :: vulkan.VertexInputBindingDescription

viewport ¶
Source

viewport :: struct {
	camera:        ^camera,
	projection:    ^projection,
	set:           descriptor_set($N=2),
	viewport_area: runtime.Maybe($T=Rect_($T=f32)),
}

Viewport structure for managing rendering areas and camera/projection settings

Contains: camera: Pointer to the camera for view transformations projection: Pointer to the projection for projection transformations set: Descriptor set for uniform resources viewport_area: Optional rectangle defining the viewport area (default: nil means window size)

Related Procedures With Parameters

Related Procedures With Returns

def_viewport

windows_platform_version ¶
Source

windows_platform_version :: struct {
	version:      windows_version,
	build_number: u32,
	service_pack: u32,
}

windows_version ¶
Source

windows_version :: enum int {
	Windows7, 
	WindowsServer2008R2, 
	Windows8, 
	WindowsServer2012, 
	Windows8Point1, 
	WindowsServer2012R2, 
	Windows10, 
	WindowsServer2016, 
	Windows11, 
	WindowsServer2019, 
	WindowsServer2022, 
	Unknown, 
}

Constants

IS_WEB ¶
Source

IS_WEB: bool : ODIN_OS == .JS

MAX_FRAMES_IN_FLIGHT ¶
Source

MAX_FRAMES_IN_FLIGHT: int : #config(MAX_FRAMES_IN_FLIGHT, 2)

is_android ¶
Source

is_android: bool : ODIN_PLATFORM_SUBTARGET == .Android

is_mobile ¶
Source

is_mobile: bool : is_android

Variables

activate ¶
Source

activate: proc "contextless" () = …

closing ¶
Source

closing: proc "contextless" () -> bool = …

descriptor_pool_size__animate_img_uniform_pool ¶
Source

@(rodata)
descriptor_pool_size__animate_img_uniform_pool: [1]descriptor_pool_size = …

descriptor_pool_size__base_uniform_pool ¶
Source

@(rodata)
descriptor_pool_size__base_uniform_pool: [1]descriptor_pool_size = …

descriptor_pool_size__single_sampler_pool ¶
Source

@(rodata)
descriptor_pool_size__single_sampler_pool: [1]descriptor_pool_size = …

descriptor_pool_size__single_storage_pool ¶
Source

@(rodata)
descriptor_pool_size__single_storage_pool: [1]descriptor_pool_size = …

descriptor_pool_size__single_uniform_pool ¶
Source

@(rodata)
descriptor_pool_size__single_uniform_pool: [1]descriptor_pool_size = …

descriptor_set_binding__animate_img_uniform_pool ¶
Source

@(rodata)
descriptor_set_binding__animate_img_uniform_pool: [1]u32 = …

descriptor_set_binding__base_uniform_pool ¶
Source

@(rodata)
descriptor_set_binding__base_uniform_pool: [1]u32 = …

descriptor_set_binding__single_pool ¶
Source

@(rodata)
descriptor_set_binding__single_pool: [1]u32 = …

destroy ¶
Source

destroy: proc()

general_input_callback ¶
Source

general_input_callback: proc(state: general_input_state) = …

general_input_change_callback ¶
Source

general_input_change_callback: proc(device: rawptr, is_connected: bool) = …

init ¶
Source

init: proc()

key_down ¶
Source

key_down: proc(keycode: key_code) = …

key_repeat ¶
Source

key_repeat: proc(keycode: key_code) = …

key_up ¶
Source

key_up: proc(keycode: key_code) = …

linux_platform ¶
Source

linux_platform: linux_platform_version

mouse_button_down ¶
Source

mouse_button_down: proc(_button_idx: button_idx, x: f32, y: f32) = …

mouse_button_up ¶
Source

mouse_button_up: proc(_button_idx: button_idx, x: f32, y: f32) = …

mouse_in ¶
Source

mouse_in: proc() = …

mouse_move ¶
Source

mouse_move: proc(x: f32, y: f32) = …

mouse_out ¶
Source

mouse_out: proc() = …

mouse_scroll ¶
Source

mouse_scroll: proc(dt: int) = …

pointer_down ¶
Source

pointer_down: proc(pointer_idx: u8, x: f32, y: f32) = …

pointer_move ¶
Source

pointer_move: proc(pointer_idx: u8, x: f32, y: f32) = …

pointer_up ¶
Source

pointer_up: proc(pointer_idx: u8, x: f32, y: f32) = …

size ¶
Source

size: proc() = …

update ¶
Source

update: proc()

Procedures

activated ¶
Source

activated :: proc "contextless" () -> bool {…}

Checks if the window is activated

Returns:
true if activated, false otherwise

allocate_command_buffers ¶
Source

allocate_command_buffers :: proc(p_cmd_buffer: [^]command_buffer, count: u32, cmd_pool: vulkan.CommandPool) {…}

android_get_asset_manager ¶
Source

android_get_asset_manager :: proc "contextless" () -> ^android.AAssetManager {…}

Gets the Android asset manager

Returns:
Pointer to the Android asset manager

android_get_device_height ¶
Source

android_get_device_height :: proc "contextless" () -> u32 {…}

Gets the device height in pixels

Returns:
Device height in pixels

android_get_device_width ¶
Source

android_get_device_width :: proc "contextless" () -> u32 {…}

Gets the device width in pixels

Returns:
Device width in pixels

android_get_internal_data_path ¶
Source

android_get_internal_data_path :: proc "contextless" () -> string {…}

Gets the internal data path for the Android app

Returns:
Internal data path as a string

android_print_current_config ¶
Source

android_print_current_config :: proc() {…}

animate_img_descriptor_set_layout ¶
Source

animate_img_descriptor_set_layout :: proc() -> vulkan.DescriptorSetLayout {…}

base_descriptor_set_layout ¶
Source

base_descriptor_set_layout :: proc "contextless" () -> vulkan.DescriptorSetLayout {…}

buffer_resource_copy_update ¶
Source

buffer_resource_copy_update :: proc(self: rawptr, data: $T, allocator: runtime.Maybe($T=Allocator) = nil) {…}

buffer_resource_create_buffer ¶
Source

buffer_resource_create_buffer :: proc(self: rawptr, option: buffer_create_option, data: []u8, is_copy: bool = false, allocator: runtime.Maybe($T=Allocator) = nil) {…}

buffer_resource_create_texture ¶
Source

buffer_resource_create_texture :: proc(
	self:      rawptr, 
	option:    texture_create_option, 
	sampler:   vulkan.Sampler, 
	data:      []u8, 
	is_copy:   bool = false, 
	allocator: runtime.Maybe($T=Allocator) = nil, 
) {…}

buffer_resource_deinit ¶
Source

buffer_resource_deinit :: proc(self: rawptr) {…}

buffer_resource_map_update_slice ¶
Source

buffer_resource_map_update_slice :: proc(self: rawptr, array: $T/[]$E, allocator: runtime.Maybe($T=Allocator) = nil) {…}

camera_deinit ¶
Source

camera_deinit :: proc(self: ^camera) {…}

Deinitializes and cleans up camera resources

Inputs:
self: Pointer to the camera to deinitialize

Returns:
None

camera_init ¶
Source

camera_init :: proc(self: ^camera, eye_vec: [3]f32 = {0, 0, -1}, focus_vec: [3]f32 = {0, 0, 0}, up_vec: [3]f32 = {0, 1, 0}) {…}

Initializes a camera with the specified view parameters

Inputs:
self: Pointer to the camera to initialize eye_vec: The position of the camera (default: {0, 0, -1}) focus_vec: The point the camera is looking at (default: {0, 0, 0}) up_vec: The up vector for the camera (default: {0, 1, 0})

Returns:
None

camera_init_matrix_raw ¶
Source

camera_init_matrix_raw :: proc(self: ^camera, mat: matrix[4, 4]f32) {…}

Initializes a camera with a raw matrix

Inputs:
self: Pointer to the camera to initialize mat: The view matrix to use

Returns:
None

camera_update ¶
Source

camera_update :: proc(self: ^camera, eye_vec: [3]f32 = {0, 0, -1}, focus_vec: [3]f32 = {0, 0, 0}, up_vec: [3]f32 = {0, 0, 1}) {…}

Updates the camera view matrix with new parameters

Inputs:
self: Pointer to the camera to update eye_vec: The new position of the camera (default: {0, 0, -1}) focus_vec: The new point the camera is looking at (default: {0, 0, 0}) up_vec: The new up vector for the camera (default: {0, 0, 1})

Returns:
None

camera_update_matrix_raw ¶
Source

camera_update_matrix_raw :: proc(self: ^camera, _mat: matrix[4, 4]f32) {…}

Updates the camera with a raw matrix

Inputs:
self: Pointer to the camera to update _mat: The new view matrix

Returns:
None

close ¶
Source

close :: proc "contextless" () {…}

Closes the engine program

Returns:
None

color_fmt_convert_default ¶
Source

color_fmt_convert_default :: proc(pixels: []u8, out: []u8, inPixelFmt: image.color_fmt = .RGBA) {…}

Converts pixel format to the default graphics format

Inputs:
pixels: Input pixel data out: Output buffer for converted pixels inPixelFmt: Input pixel format (default: .RGBA)

Returns:
None

color_fmt_convert_default_overlap ¶
Source

color_fmt_convert_default_overlap :: proc(pixels: []u8, out: []u8, inPixelFmt: image.color_fmt = .RGBA) {…}

Converts pixel format to the default graphics format (in-place conversion)

Inputs:
pixels: Input pixel data out: Output buffer for converted pixels (can overlap with input) inPixelFmt: Input pixel format (default: .RGBA)

Returns:
None

color_transform_deinit ¶
Source

color_transform_deinit :: proc(self: ^color_transform) {…}

Deinitializes and cleans up color transform resources

Inputs:
self: Pointer to the color transform to deinitialize

Returns:
None

color_transform_init_matrix_raw ¶
Source

color_transform_init_matrix_raw :: proc(self: ^color_transform, mat: matrix[4, 4]f32 = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1}) {…}

color_transform_update_matrix_raw ¶
Source

color_transform_update_matrix_raw :: proc(self: ^color_transform, _mat: matrix[4, 4]f32) {…}

Updates the color transform with a raw matrix

Inputs:
self: Pointer to the color transform to update _mat: The new color transform matrix

Returns:
None

convert_mouse_pos ¶
Source

convert_mouse_pos :: proc "contextless" (pos: [2]f32) -> [2]f32 {…}

Converts mouse position from window coordinates to centered coordinates

Inputs:
pos: Mouse position in window coordinates

Returns:
Mouse position in centered coordinates (origin at window center)

create_graphics_pipeline ¶
Source

create_graphics_pipeline :: proc(
	self:                ^object_pipeline, 
	stages:              []vulkan.PipelineShaderStageCreateInfo, 
	depth_stencil_state: vulkan.PipelineDepthStencilStateCreateInfo, 
	viewport_state:      vulkan.PipelineViewportStateCreateInfo, 
	pVertex_input_state: ^vulkan.PipelineVertexInputStateCreateInfo, 
	color_blend_state:   vulkan.PipelineColorBlendStateCreateInfo, 
) -> bool {…}

create_random_texture ¶
Source

create_random_texture :: proc(width, height: u32, out_texture: ^texture, allocator := context.allocator) {…}

Creates a random RGBA texture with the specified dimensions

Inputs:
width: The width of the texture in pixels height: The height of the texture in pixels out_texture: Pointer to the texture structure to initialize allocator: The allocator to use for the texture data

Returns:
None

create_random_texture_grey ¶
Source

create_random_texture_grey :: proc(width, height: u32, out_texture: ^texture, allocator := context.allocator) {…}

Creates a random grayscale texture with the specified dimensions

Returns:
None

custom_object_pipeline_init ¶
Source

custom_object_pipeline_init :: proc(
	self:                   ^object_pipeline, 
	descriptor_set_layouts: []vulkan.DescriptorSetLayout, 
	vertex_input_binding:   runtime.Maybe($T=[]VertexInputBindingDescription), 
	vertex_input_attribute: runtime.Maybe($T=[]VertexInputAttributeDescription), 
	draw_method:            object_draw_method, 
	vertex_shader:          runtime.Maybe($T=shader_code), 
	pixel_shader:           runtime.Maybe($T=shader_code), 
	geometry_shader:        runtime.Maybe($T=shader_code) = nil, 
	depth_stencil_state:    runtime.Maybe($T=PipelineDepthStencilStateCreateInfo) = nil, 
	color_blend_state:      runtime.Maybe($T=PipelineColorBlendStateCreateInfo) = nil, 
	shader_lang:            shader_lang = .GLSL, 
	allocator := context.allocator, 
) -> bool {…}

def_camera ¶
Source

def_camera :: proc() -> ^camera {…}

Returns a pointer to the default camera

Returns:
Pointer to the default camera

def_color_transform ¶
Source

def_color_transform :: proc "contextless" () -> ^color_transform {…}

def_projection ¶
Source

def_projection :: proc() -> ^projection {…}

Returns a pointer to the default projection

Returns:
Pointer to the default projection

def_viewport ¶
Source

def_viewport :: proc "contextless" () -> ^viewport {…}

default_color_fmt ¶
Source

default_color_fmt :: proc() -> image.color_fmt {…}

Returns the default color format based on the graphics origin format

Returns:
The default color format for the current graphics system

default_multisample_state ¶
Source

default_multisample_state :: proc "contextless" () -> ^vulkan.PipelineMultisampleStateCreateInfo {…}

default_render_pass ¶
Source

default_render_pass :: proc "contextless" () -> vulkan.RenderPass {…}

dt ¶
Source

dt :: proc "contextless" () -> f64 {…}

dt_u64 ¶
Source

dt_u64 :: proc "contextless" () -> u64 {…}

engine_main ¶
Source

engine_main :: proc(
	window_title:  cstring = "SpaceEngine", 
	window_x:      runtime.Maybe($T=int) = nil, 
	window_y:      runtime.Maybe($T=int) = nil, 
	window_width:  runtime.Maybe($T=int) = nil, 
	window_height: runtime.Maybe($T=int) = nil, 
	v_sync:        v_sync = .Double, 
	screen_mode:   screen_mode = .Window, 
	screen_idx:    int = 0, 
) {…}

Main entry point for the engine

Initializes the engine, creates a window, and runs the main loop

Inputs:
window_title: Title of the window (default: "SpaceEngine") window_x: X position of the window (default: nil) window_y: Y position of the window (default: nil) window_width: Width of the window (default: nil) window_height: Height of the window (default: nil) v_sync: Vertical sync mode (default: .Double) screen_mode: Screen mode (default: .Window) screen_idx: Screen index (default: 0)

Returns:
None

exiting ¶
Source

exiting :: proc "contextless" () -> bool {…}

free_command_buffers ¶
Source

free_command_buffers :: proc(p_cmd_buffer: [^]command_buffer, count: u32, cmd_pool: vulkan.CommandPool) {…}

get_animate_img_pipeline ¶
Source

get_animate_img_pipeline :: proc "contextless" () -> ^object_pipeline {…}

get_default_linear_sampler ¶
Source

get_default_linear_sampler :: proc "contextless" () -> vulkan.Sampler {…}

Gets the default linear sampler

Returns:
The default linear sampler

get_default_nearest_sampler ¶
Source

get_default_nearest_sampler :: proc "contextless" () -> vulkan.Sampler {…}

Gets the default nearest sampler

Returns:
The default nearest sampler

get_fps ¶
Source

get_fps :: proc "contextless" () -> f64 {…}

Gets the current frames per second

Returns:
Current FPS, or 0 if delta time is 0

get_graphics_origin_format ¶
Source

get_graphics_origin_format :: proc "contextless" () -> vulkan.Format {…}

Gets the graphics origin format

Returns:
The Vulkan format used as the graphics origin format

get_img_pipeline ¶
Source

get_img_pipeline :: proc "contextless" () -> ^object_pipeline {…}

get_linear_sampler ¶
Source

get_linear_sampler :: proc "contextless" () -> vulkan.Sampler {…}

get_max_frame ¶
Source

get_max_frame :: proc "contextless" () -> f64 {…}

get_monitor_from_window ¶
Source

get_monitor_from_window :: proc "contextless" () -> ^monitor_info {…}

get_monitors ¶
Source

get_monitors :: proc "contextless" () -> []monitor_info {…}

get_nearest_sampler ¶
Source

get_nearest_sampler :: proc "contextless" () -> vulkan.Sampler {…}

get_platform_version ¶
Source

get_platform_version :: proc "contextless" () -> linux_platform_version {…}

get_primary_monitor ¶
Source

get_primary_monitor :: proc "contextless" () -> ^monitor_info {…}

get_processor_core_len ¶
Source

get_processor_core_len :: proc "contextless" () -> int {…}

get_screen_mode ¶
Source

get_screen_mode :: proc "contextless" () -> screen_mode {…}

get_shape_pipeline ¶
Source

get_shape_pipeline :: proc "contextless" () -> ^object_pipeline {…}

get_v_sync ¶
Source

get_v_sync :: proc "contextless" () -> v_sync {…}

Gets the current vertical sync mode

Returns:
The current vertical sync mode

get_vulkan_version ¶
Source

get_vulkan_version :: proc "contextless" () -> VULKAN_VERSION {…}

graphics_cmd_bind_descriptor_sets ¶
Source

graphics_cmd_bind_descriptor_sets :: proc "contextless" (
	cmd:                  command_buffer, 
	pipeline_bind_point:  vulkan.PipelineBindPoint, 
	layout:               vulkan.PipelineLayout, 
	first_set:            u32, 
	descriptor_set_count: u32, 
	p_descriptor_sets:    ^vulkan.DescriptorSet, 
	dynamic_offset_count: u32, 
	p_dynamic_offsets:    ^u32, 
) {…}

graphics_cmd_bind_index_buffer ¶
Source

graphics_cmd_bind_index_buffer :: proc "contextless" (cmd: command_buffer, buffer: ^buffer_resource, offset: vulkan.DeviceSize, index_type: vulkan.IndexType) {…}

graphics_cmd_bind_pipeline ¶
Source

graphics_cmd_bind_pipeline :: proc "contextless" (cmd: command_buffer, pipeline_bind_point: vulkan.PipelineBindPoint, pipeline: vulkan.Pipeline) {…}

graphics_cmd_bind_vertex_buffers ¶
Source

graphics_cmd_bind_vertex_buffers :: proc(cmd: command_buffer, first_binding: u32, binding_count: u32, p_buffers: []^buffer_resource, p_offsets: ^vulkan.DeviceSize) {…}

graphics_cmd_draw ¶
Source

graphics_cmd_draw :: proc "contextless" (cmd: command_buffer, vertex_count: u32, instance_count: u32, first_vertex: u32, first_instance: u32) {…}

graphics_cmd_draw_indexed ¶
Source

graphics_cmd_draw_indexed :: proc "contextless" (
	cmd:            command_buffer, 
	index_count:    u32, 
	instance_count: u32, 
	first_index:    u32, 
	vertex_offset:  i32, 
	first_instance: u32, 
) {…}

graphics_destriptor_set_layout_init ¶
Source

graphics_destriptor_set_layout_init :: proc(bindings: []vulkan.DescriptorSetLayoutBinding) -> vulkan.DescriptorSetLayout {…}

graphics_device ¶
Source

graphics_device :: proc "contextless" () -> vulkan.Device {…}

graphics_get_resource ¶
Source

graphics_get_resource :: proc "contextless" (self: rawptr) -> union_resource {…}

Get last resource from stack (most recently created)

graphics_get_resource_draw ¶
Source

graphics_get_resource_draw :: proc "contextless" (self: rawptr) -> union_resource {…}

Get first resource from stack (for rendering - oldest)

image_binding_sets_and_draw ¶
Source

image_binding_sets_and_draw :: proc "contextless" (cmd: command_buffer, imageSet: ^i_descriptor_set, viewSet: ^i_descriptor_set, textureSet: ^i_descriptor_set) {…}

Binds descriptor sets and draws an image

Inputs:
cmd: Command buffer to record draw commands imageSet: Descriptor set for the image transform uniforms textureSet: Descriptor set for the texture

Returns:
None

image_change_color_transform ¶
Source

image_change_color_transform :: proc(self: ^image, colorTransform: ^color_transform) {…}

image_init ¶
Source

image_init :: proc(self: ^image, src: ^texture, colorTransform: ^color_transform = nil, vtable: ^iobject_vtable = nil) {…}

image_update_texture ¶
Source

image_update_texture :: proc "contextless" (self: ^image, src: ^texture) {…}

image_update_camera :: #force_inline proc(self:^image, camera:^camera) { iobject_update_camera(self, camera) } image_update_projection :: #force_inline proc(self:^image, projection:^projection) { iobject_update_projection(self, projection) }

image_update_transform ¶
Source

image_update_transform :: proc(self: ^image, pos: [3]f32, rotation: f32 = 0.0, scale: [2]f32 = {1, 1}, pivot: [2]f32 = {0.0, 0.0}) {…}

image_update_transform_matrix_raw ¶
Source

image_update_transform_matrix_raw :: proc(self: ^image, _mat: matrix[4, 4]f32) {…}

img_descriptor_set_layout ¶
Source

img_descriptor_set_layout :: proc "contextless" () -> vulkan.DescriptorSetLayout {…}

iobject_deinit ¶
Source

iobject_deinit :: proc(self: ^iobject) {…}

Deinitializes and cleans up object resources

Inputs:
self: Pointer to the object to deinitialize

Returns:
None

iobject_draw ¶
Source

iobject_draw :: proc(self: ^iobject, cmd: command_buffer, viewport: ^viewport) {…}

Draws the object using its vtable draw function

Inputs:
self: Pointer to the object cmd: Command buffer to record draw commands viewport: viewport to draw the object. you can use multiple viewports to perform a draw call for each element in the viewport array.

Returns:
None

iobject_init ¶
Source

iobject_init :: proc(self: ^iobject) {…}

iobject_size ¶
Source

iobject_size :: proc(self: ^iobject) {…}

iobject_update ¶
Source

iobject_update :: proc(self: ^iobject) {…}

is_main_thread ¶
Source

is_main_thread :: proc "contextless" () -> bool {…}

is_mouse_out ¶
Source

is_mouse_out :: proc "contextless" () -> bool {…}

Checks if the mouse is outside the window

Returns:
true if the mouse is outside the window, false otherwise

itransform_object_change_color_transform ¶
Source

itransform_object_change_color_transform :: proc(self: ^itransform_object, _color_transform: ^color_transform) {…}

itransform_object_cvt_area_window_coord ¶
Source

itransform_object_cvt_area_window_coord :: proc(self: ^itransform_object, area: linalg.Area($T=f32), viewport: ^viewport, allocator := context.allocator) -> linalg.Area($T=f32) {…}

Converts the area to window coordinate. window coordinate is top-left origin and bottom-right is (window_width(), window_height()).

Note: if result area is [][2]f32, it allocates memory for the result area.

Inputs:
self: Pointer to the object area: Area to convert viewport: The viewport to which self belongs. If nil, the default viewport will be used. allocator: Allocator to use for the result area.

Returns:
Area in window coordinates

itransform_object_init ¶
Source

itransform_object_init :: proc(self: ^itransform_object, _color_transform: ^color_transform = nil, vtable: ^iobject_vtable = nil) {…}

itransform_object_update_transform ¶
Source

itransform_object_update_transform :: proc(self: ^itransform_object, pos: [3]f32, rotation: f32 = 0.0, scale: [2]f32 = {1.0, 1.0}, pivot: [2]f32 = {0.0, 0.0}) {…}

itransform_object_update_transform_matrix_raw ¶
Source

itransform_object_update_transform_matrix_raw :: proc(self: ^itransform_object, _mat: matrix[4, 4]f32) {…}

layer_add_object ¶
Source

layer_add_object :: proc(cmd: ^layer, obj: ^iobject) {…}

Adds an object to the render command's scene

Inputs:
cmd: Pointer to the render command obj: Pointer to the object to add

Returns:
None

layer_add_objects ¶
Source

layer_add_objects :: proc(cmd: ^layer, .. objs: ..^iobject) {…}

Adds multiple objects to the render command's scene

Inputs:
cmd: Pointer to the render command objs: Variable number of object pointers to add

Returns:
None

layer_change_scene ¶
Source

layer_change_scene :: proc "contextless" (cmd: ^layer, _scene: ^[dynamic]^iobject) {…}

Changes the scene of the render command

layer_deinit ¶
Source

layer_deinit :: proc(cmd: ^layer) {…}

Deinitializes and cleans up render command resources

Inputs:
cmd: Pointer to the render command to deinitialize

Returns:
None

layer_get_object ¶
Source

layer_get_object :: proc(cmd: ^layer, index: int) -> ^iobject {…}

Gets an object from the render command's scene by index

Inputs:
cmd: Pointer to the render command index: The index of the object to get

Returns:
Pointer to the object at the specified index

layer_get_object_idx ¶
Source

layer_get_object_idx :: proc(cmd: ^layer, obj: ^iobject) -> int {…}

Gets the index of an object in the render command's scene

Inputs:
cmd: Pointer to the render command obj: Pointer to the object to find

Returns:
The index of the object, or -1 if not found

layer_get_object_len ¶
Source

layer_get_object_len :: proc(cmd: ^layer) -> int {…}

Gets the number of objects in the render command's scene

Inputs:
cmd: Pointer to the render command

Returns:
The number of objects in the scene

layer_has_object ¶
Source

layer_has_object :: proc(cmd: ^layer, obj: ^iobject) -> bool {…}

Checks if an object is in the render command's scene

Inputs:
cmd: Pointer to the render command obj: Pointer to the object to check

Returns:
true if the object is in the scene, false otherwise

layer_hide ¶
Source

layer_hide :: proc "contextless" (_cmd: ^layer) -> bool {…}

Sets the render command as hidden

Inputs:
_cmd: Pointer to the render command to hide

Returns:
true if successful, false if the command was not found

layer_init ¶
Source

layer_init :: proc(_scene: ^[dynamic]^iobject, allocator := context.allocator) -> (cmd: ^layer, err: runtime.Allocator_Error) #optional_ok {…}

Initializes a new render command structure

Make layer.scene manually. _scene can be nil

Returns:
Pointer to the initialized render command Allocator error if allocation failed

layer_remove_all ¶
Source

layer_remove_all :: proc(cmd: ^layer) {…}

Removes all objects from the render command's scene

Inputs:
cmd: Pointer to the render command

Returns:
None

layer_remove_object ¶
Source

layer_remove_object :: proc(cmd: ^layer, obj: ^iobject) {…}

Removes an object from the render command's scene

Inputs:
cmd: Pointer to the render command obj: Pointer to the object to remove

Returns:
None

layer_show ¶
Source

layer_show :: proc(_cmd: ^layer) {…}

Sets the render command as visible

Inputs:
_cmd: Pointer to the render command to set visible

Returns:
true if successful, false if the command was not found

layer_size_all ¶
Source

layer_size_all :: proc() {…}

size update all render commands' projection (only ortho windowprojection)

Inputs:
None

Returns:
None

monitor_lock ¶
Source

monitor_lock :: proc "contextless" () {…}

monitor_try_lock ¶
Source

monitor_try_lock :: proc "contextless" () -> bool {…}

monitor_unlock ¶
Source

monitor_unlock :: proc "contextless" () {…}

mouse_pos ¶
Source

mouse_pos :: proc "contextless" () -> [2]f32 {…}

Gets the current mouse position

Returns:
Current mouse position in window coordinates

object_pipeline_deinit ¶
Source

object_pipeline_deinit :: proc(self: ^object_pipeline) {…}

paused ¶
Source

paused :: proc "contextless" () -> bool {…}

Checks if the engine is paused

Returns:
true if paused, false otherwise

projection_deinit ¶
Source

projection_deinit :: proc(self: ^projection) {…}

Deinitializes and cleans up projection resources

Inputs:
self: Pointer to the projection to deinitialize

Returns:
None

projection_init_matrix_ortho ¶
Source

projection_init_matrix_ortho :: proc(
	self:                   ^projection, 
	left:                   f32, 
	right:                  f32, 
	bottom:                 f32, 
	top:                    f32, 
	near:                   f32 = 0.1, 
	far:                    f32 = 100, 
	flip_z_axis_for_vulkan: bool = true, 
) {…}

Initializes an orthographic projection matrix

Inputs:
self: Pointer to the projection to initialize left: Left plane coordinate right: Right plane coordinate bottom: Bottom plane coordinate top: Top plane coordinate near: Near plane distance (default: 0.1) far: Far plane distance (default: 100) flip_z_axis_for_vulkan: Whether to flip Z axis for Vulkan (default: true)

Returns:
None

projection_init_matrix_ortho_window ¶
Source

projection_init_matrix_ortho_window :: proc(
	self:                   ^projection, 
	width:                  f32, 
	height:                 f32, 
	near:                   f32 = 0.1, 
	far:                    f32 = 100, 
	flip_z_axis_for_vulkan: bool = true, 
) {…}

Initializes an orthographic projection matrix based on window dimensions

Inputs:
self: Pointer to the projection to initialize width: Window width height: Window height near: Near plane distance (default: 0.1) far: Far plane distance (default: 100) flip_z_axis_for_vulkan: Whether to flip Z axis for Vulkan (default: true)

Returns:
None

projection_init_matrix_perspective ¶
Source

projection_init_matrix_perspective :: proc(
	self:                   ^projection, 
	fov:                    f32, 
	aspect:                 f32 = 0, 
	near:                   f32 = 0.1, 
	far:                    f32 = 100, 
	flip_z_axis_for_vulkan: bool = true, 
) {…}

Initializes a perspective projection matrix

Note: If aspect is 0, the window aspect ratio will be used

Inputs:
self: Pointer to the projection to initialize fov: Field of view angle in radians aspect: Aspect ratio (width/height). If 0, uses window aspect (default: 0) near: Near plane distance (default: 0.1) far: Far plane distance (default: 100) flip_z_axis_for_vulkan: Whether to flip Z axis for Vulkan (default: true)

Returns:
None

projection_init_matrix_raw ¶
Source

projection_init_matrix_raw :: proc(self: ^projection, mat: matrix[4, 4]f32) {…}

Initializes a projection with a raw matrix

Inputs:
self: Pointer to the projection to initialize mat: The projection matrix to use

Returns:
None

projection_size ¶
Source

projection_size :: proc(self: ^projection) {…}

projection size update (automatically called when window size changes)

Inputs:
self: Pointer to the projection to update

Returns:
None

projection_update_matrix_raw ¶
Source

projection_update_matrix_raw :: proc(self: ^projection, _mat: matrix[4, 4]f32) {…}

Updates the projection with a raw matrix

Inputs:
self: Pointer to the projection to update _mat: The new projection matrix

Returns:
None

projection_update_ortho ¶
Source

projection_update_ortho :: proc(
	self:                   ^projection, 
	left:                   f32, 
	right:                  f32, 
	bottom:                 f32, 
	top:                    f32, 
	near:                   f32 = 0.1, 
	far:                    f32 = 100, 
	flip_z_axis_for_vulkan: bool = true, 
) {…}

Updates an orthographic projection matrix

Inputs:
self: Pointer to the projection to update left: Left plane coordinate right: Right plane coordinate bottom: Bottom plane coordinate top: Top plane coordinate near: Near plane distance (default: 0.1) far: Far plane distance (default: 100) flip_z_axis_for_vulkan: Whether to flip Z axis for Vulkan (default: true)

Returns:
None

projection_update_ortho_window ¶
Source

projection_update_ortho_window :: proc(
	self:                   ^projection, 
	width:                  f32, 
	height:                 f32, 
	near:                   f32 = 0.1, 
	far:                    f32 = 100, 
	flip_z_axis_for_vulkan: bool = true, 
) {…}

Updates an orthographic projection matrix based on window dimensions

Inputs:
self: Pointer to the projection to update width: Window width height: Window height near: Near plane distance (default: 0.1) far: Far plane distance (default: 100) flip_z_axis_for_vulkan: Whether to flip Z axis for Vulkan (default: true)

Returns:
None

projection_update_perspective ¶
Source

projection_update_perspective :: proc(
	self:                 ^projection, 
	fov:                  f32, 
	aspect:               f32 = 0, 
	near:                 f32 = 0.1, 
	far:                  f32 = 100, 
	flip_axis_for_vulkan: bool = true, 
) {…}

Updates a perspective projection matrix

Inputs:
self: Pointer to the projection to update fov: Field of view angle in radians aspect: Aspect ratio (width/height). If 0, uses window aspect (default: 0) near: Near plane distance (default: 0.1) far: Far plane distance (default: 100) flip_axis_for_vulkan: Whether to flip axis for Vulkan (default: true)

Returns:
None

r_2d_matrix ¶
Source

r_2d_matrix :: proc "contextless" (r: f32) -> matrix[4, 4]f32 {…}

render_guard ¶
Source

render_guard :: proc "contextless" () -> bool {…}

!DO NOT CALL THIS FROM WITHIN ENGINE CALLBACKS

render_lock ¶
Source

render_lock :: proc "contextless" () {…}

!DO NOT CALL THIS FROM WITHIN ENGINE CALLBACKS

render_try_lock ¶
Source

render_try_lock :: proc "contextless" () -> bool {…}

!DO NOT CALL THIS FROM WITHIN ENGINE CALLBACKS

render_unlock ¶
Source

render_unlock :: proc "contextless" () {…}

!DO NOT CALL THIS FROM WITHIN ENGINE CALLBACKS

rt_2d_matrix ¶
Source

rt_2d_matrix :: proc "contextless" (t: [3]f32, r: f32) -> matrix[4, 4]f32 {…}

s_2d_matrix ¶
Source

s_2d_matrix :: proc "contextless" (s: [2]f32) -> matrix[4, 4]f32 {…}

second_to_nano_second ¶
Source

second_to_nano_second :: proc "contextless" (_int: $T, _dec: $T) -> $T {…}

_int * 1000000000 + _dec

second_to_nano_second2 ¶
Source

second_to_nano_second2 :: proc "contextless" (_sec: $T, _milisec: $T, _usec: $T, _nsec: $T) -> $T {…}

set_full_screen_mode ¶
Source

set_full_screen_mode :: proc "contextless" (monitor: ^monitor_info) {…}

Sets the window to fullscreen mode on the specified monitor

Inputs:
monitor: Pointer to the monitor to use for fullscreen

Returns:
None

set_max_frame ¶
Source

set_max_frame :: proc "contextless" (_maxframe: f64) {…}

set_render_clear_color ¶
Source

set_render_clear_color :: proc "contextless" (_color: [4]f32) {…}

set_uniform_resources_transform_object ¶
Source

set_uniform_resources_transform_object :: proc(self: ^itransform_object, resources: []union_resource) {…}

set_v_sync ¶
Source

set_v_sync :: proc "contextless" (v_sync: v_sync) {…}

Sets the vertical sync mode

Inputs:
v_sync: The vertical sync mode to set

Returns:
None

set_window_icon ¶
Source

set_window_icon :: proc "contextless" (icons: []glfw_bindings.Image) {…}

set_window_mode ¶
Source

set_window_mode :: proc "contextless" () {…}

Sets the window to windowed mode

Returns:
None

sr_2d_matrix ¶
Source

sr_2d_matrix :: proc "contextless" (s: [2]f32, r: f32) -> matrix[4, 4]f32 {…}

sr_2d_matrix2 ¶
Source

sr_2d_matrix2 :: proc "contextless" (s: [2]f32, r: f32, cp: [2]f32) -> runtime.Maybe($T=matrix[4, 4]f32) {…}

src_2d_matrix ¶
Source

src_2d_matrix :: proc "contextless" (s: [2]f32, r: f32, cp: [2]f32) -> matrix[4, 4]f32 {…}

srt_2d_matrix ¶
Source

srt_2d_matrix :: proc "contextless" (t: [3]f32, s: [2]f32, r: f32) -> matrix[4, 4]f32 {…}

srt_2d_matrix2 ¶
Source

srt_2d_matrix2 :: proc "contextless" (t: [3]f32, s: [2]f32, r: f32, cp: [2]f32) -> matrix[4, 4]f32 {…}

srtc_2d_matrix ¶
Source

srtc_2d_matrix :: proc "contextless" (t: [3]f32, s: [2]f32, r: f32, cp: [2]f32) -> matrix[4, 4]f32 {…}

st_2d_matrix ¶
Source

st_2d_matrix :: proc "contextless" (t: [3]f32, s: [2]f32) -> matrix[4, 4]f32 {…}

start_console ¶
Source

start_console :: proc() {…}

t_2d_matrix ¶
Source

t_2d_matrix :: proc "contextless" (t: [3]f32) -> matrix[4, 4]f32 {…}

texture_array_deinit ¶
Source

texture_array_deinit :: proc(self: ^texture_array) {…}

texture_array_init ¶
Source

texture_array_init :: proc(
	self:       ^texture_array, 
	width:      u32, 
	height:     u32, 
	count:      u32, 
	pixels:     []u8, 
	sampler:    vulkan.Sampler = 0, 
	inPixelFmt: image.color_fmt = .RGBA, 
) {…}

Initializes a texture array with multiple textures

Inputs:
self: Pointer to the texture array to initialize width: Width of each texture height: Height of each texture count: Number of textures in the array pixels: Pixel data for all textures sampler: Sampler to use (default: 0, uses default linear sampler) inPixelFmt: Input pixel format (default: .RGBA)

Returns:
None

texture_deinit ¶
Source

texture_deinit :: proc(self: ^texture) {…}

texture_fmt_bit_size ¶
Source

texture_fmt_bit_size :: proc(fmt: texture_fmt) -> u32 {…}

Returns the bit size of the given texture format

Inputs:
fmt: The texture format to get the bit size for

Returns:
The number of bits per pixel for the given format

texture_fmt_is_depth ¶
Source

texture_fmt_is_depth :: proc "contextless" (t: texture_fmt) -> bool {…}

Checks if the given texture format is a depth format

Inputs:
t: The texture format to check

Returns:
true if the format is a depth format, false otherwise

texture_fmt_to_color_fmt ¶
Source

texture_fmt_to_color_fmt :: proc(t: texture_fmt) -> image.color_fmt {…}

Converts a texture format to a color format

Inputs:
t: The texture format to convert

Returns:
The corresponding color format, or .Unknown if unsupported

texture_init ¶
Source

texture_init :: proc(
	self:             ^texture, 
	width:            u32, 
	height:           u32, 
	pixels:           []u8, 
	pixels_allocator: runtime.Maybe($T=Allocator) = nil, 
	sampler:          vulkan.Sampler = 0, 
	resource_usage:   resource_usage = .GPU, 
	in_pixel_fmt:     image.color_fmt = .RGBA, 
) {…}

Initializes a texture with the given width, height, pixels, and sampler

Note: pixels_allocator is used to delete pixels when texture init is done. (async) If pixels_allocator is nil, not delete pixels. if you pixel allocated with any image_converter, you should make custom allocator to destory this image_converter.

Inputs:
self: Pointer to the texture to initialize width: Width of the texture height: Height of the texture pixels: Pixels of the texture pixels_allocator: The allocator to use for the pixels sampler: The sampler to use for the texture resource_usage: The resource usage to use for the texture in_pixel_fmt: The pixel format to use for the texture

Returns:
None

Example:

package image_test

import "core:debug/trace"
import "base:runtime"
import "core:engine"
import "core:log"

panda_img : []u8 = #load("res/panda.qoi")

panda_img_allocator_proc :: proc(allocator_data:rawptr, mode: runtime.Allocator_Mode, size:int, alignment:int, old_memory:rawptr, old_size:int, loc := #caller_location) -> ([]byte, runtime.Allocator_Error) {
	#partial switch mode {
	case .Free:
		qoiD :^qoi_converter = auto_cast allocator_data
		qoi_converter_deinit(qoiD)
		free(qoiD, def_allocator())
	}
	return nil, nil
}

init :: proc() {
	qoiD := new(qoi_converter, def_allocator())
	
	imgData, errCode := image_converter_load(qoiD, panda_img, .RGBA)
	if errCode != nil {
		log.panicf("image_converter_load : %s\n", errCode)
	}
	
	texture_init(&texture,
	u32(image_converter_width(qoiD)), u32(image_converter_height(qoiD)), imgData,
	runtime.Allocator{
		procedure = panda_img_allocator_proc,
		data = auto_cast qoiD,
	})
}

texture_init_depth_stencil ¶
Source

texture_init_depth_stencil :: proc(self: ^texture, width: u32, height: u32) {…}

texture_init_grey ¶
Source

texture_init_grey :: proc(
	self:             ^texture, 
	width:            u32, 
	height:           u32, 
	pixels:           []u8, 
	pixels_allocator: runtime.Maybe($T=Allocator) = nil, 
	sampler:          vulkan.Sampler = 0, 
	resource_usage:   resource_usage = .GPU, 
) {…}

texture_init_msaa ¶
Source

texture_init_msaa :: proc(self: ^texture, width: u32, height: u32) {…}

texture_pixel_perfect_point ¶
Source

texture_pixel_perfect_point :: proc "contextless" (tex: ^texture, p: [2]f32, canvasW: f32, canvasH: f32, pivot: image_center_pt_pos) -> [2]f32 {…}

Calculates pixel-perfect point position for a texture

Inputs:
tex: Pointer to texture p: Point to adjust canvasW: Canvas width canvasH: Canvas height pivot: Pivot position for the image

Returns:
Adjusted point for pixel-perfect rendering

texture_point_in ¶
Source

texture_point_in :: proc(texture: ^texture, point: [2]f32, mat: matrix[4, 4]f32, ref_viewport: ^viewport = nil) -> bool {…}

Checks if a window-space point hits the textured quad (with optional alpha test). Uses same transform as image shader: proj view model * scale(tex_width, tex_height, 1).

Inputs:
texture: Texture to test (used for size and pixel_data alpha). point: Window coordinates (0,0 top-left to window_size bottom-right). mat: Model matrix of the quad. ref_viewport: Viewport for proj/camera; if nil, def_viewport() is used. alpha_threshold: Pixels with alpha >= this are considered hit; use 0 to skip alpha test when pixel_data is set.

Returns:
true if point is inside the quad and (if pixel_data present) alpha >= alpha_threshold.

update_descriptor_set ¶
Source

update_descriptor_set :: proc(descriptor_sets: ^i_descriptor_set) {…}

viewport_descriptor_set_layout ¶
Source

viewport_descriptor_set_layout :: proc "contextless" () -> vulkan.DescriptorSetLayout {…}

viewport_init_update ¶
Source

viewport_init_update :: proc(self: ^viewport) {…}

Initializes or updates the viewport's descriptor set. You should call this function after changing the camera, projection pointer or initializing the viewport.

Inputs:
self: Pointer to the viewport to initialize and update

Returns:
None

webgl_create_context ¶
Source

webgl_create_context :: proc() {…}

webgl_destroy ¶
Source

webgl_destroy :: proc() {…}

webgl_start ¶
Source

webgl_start :: proc() {…}

window_height ¶
Source

window_height :: proc "contextless" () -> int {…}

Gets the window height

Returns:
Window height in pixels

window_width ¶
Source

window_width :: proc "contextless" () -> int {…}

Gets the window width

Returns:
Window width in pixels

window_x ¶
Source

window_x :: proc "contextless" () -> int {…}

Gets the window X position

Returns:
Window X position in pixels

window_y ¶
Source

window_y :: proc "contextless" () -> int {…}

Gets the window Y position

Returns:
Window Y position in pixels

windows_set_res_icon ¶
Source

windows_set_res_icon :: proc "contextless" (icon_resource_number: int) {…}

Procedure Groups

This section is empty.

Source Files

Generation Information

Generated with odin version dev-v0.0.1 (vendor "odin") Linux_amd64 @ 2026-01-30 10:23:15.863590443 +0000 UTC

package core:engineSource

Index

Types

Related Procedures With Returns

Related Procedures With Parameters

Related Procedures With Parameters

Related Procedures With Parameters

Related Procedures With Returns

Related Procedures With Parameters

Related Procedures With Returns

Related Procedures With Parameters

Related Procedures With Parameters

Related Procedures With Parameters

Related Procedures With Parameters

Procedures Through `using` From itransform_object

Procedures Through `using` From iobject

Related Procedures With Parameters

Related Procedures With Parameters

Related Procedures With Returns

Related Procedures With Parameters

Related Procedures With Parameters

Procedures Through `using` From iobject

Related Procedures With Parameters

Related Procedures With Returns

Related Procedures With Returns

Related Procedures With Parameters

Related Procedures With Returns

Related Procedures With Parameters

Related Procedures With Parameters

Related Procedures With Returns

Procedures Through `using` From i_descriptor_set

Related Procedures With Parameters

Related Procedures With Returns

Related Procedures With Parameters

Related Procedures With Parameters

Related Procedures With Parameters

Related Procedures With Returns

Related Procedures With Parameters

Related Procedures With Parameters

Related Procedures With Parameters

Procedures Through `using` From texture

Related Procedures With Parameters

Related Procedures With Parameters

Procedures Through `using` From texture

Related Procedures With Returns

Related Procedures With Parameters

Related Procedures With Returns

Related Procedures With Parameters

Related Procedures With Returns

Constants

Variables

Procedures

package core:engine
Source