Abstract class for constructing and configuring an application. The ApplicationBuilder serves as the entry point for setting up the application's program, configuration, and other components.

ApplicationBuilderJS

class ApplicationBuilderJS : ApplicationBuilder

ApplicationBuilderJVM

class ApplicationBuilderJVM : ApplicationBuilder

ApplicationConfiguration

object ApplicationConfiguration

Application configuration object

ApplicationMouse

class ApplicationMouse(application: () -> Application) : MouseEvents

Mouse events

ApplicationPreload

open class ApplicationPreload

ApplicationPreload can be used to configure Application and Program without changing user code.

ApplicationWindow

abstract class ApplicationWindow(val program: Program)

ApplicationWindowMouse

class ApplicationWindowMouse(applicationWindow: () -> ApplicationWindow) : MouseEvents

AssetMetadata

@JvmRecord

data class AssetMetadata(val programName: String, val assetBaseName: String, val assetProperties: Map<String, String>)

CharacterEvent

data class CharacterEvent(val character: Char, val modifiers: Set<KeyModifier>)

Represents an event triggered by a character input, typically used in text input scenarios.

Clipboard

interface Clipboard

Interface representing a clipboard for accessing and modifying its contents.

Clock

interface Clock

Configuration

class Configuration

Configuration class to customize the behavior, appearance, and settings of a window in an application.

CursorType

enum CursorType : Enum<CursorType>

Represents the type of cursor used within an application.

Dispatcher

expect class Dispatcher

actual class Dispatcher

actual class Dispatcher : MainCoroutineDispatcher, Delay

Display

abstract class Display

Any coordinates or positions are provided as screen coordinates, which may or may not be equivalent to pixel coordinates, depending on your setup.

DropEvent

@JvmRecord

data class DropEvent(val position: Vector2, val files: List<String>)

window drop item event message

Extension

interface Extension

Represents an interface for creating extensions to enhance the functionality of a host program. Extensions allow developers to hook into the lifecycle of the program, enabling custom behavior during setup, drawing, and shutdown phases.

ExtensionDslMarker

@DslMarker

annotation class ExtensionDslMarker

ExtensionHost

interface ExtensionHost : InputEvents

Represents a host for managing and executing extensions within a program. This interface provides methods for adding, configuring, and executing extensions at different stages of the program's lifecycle.

ExtensionStage

enum ExtensionStage : Enum<ExtensionStage>

Represents the various stages of an extension's lifecycle in the application.

Fullscreen

enum Fullscreen : Enum<Fullscreen>

Fullscreen mode

InputEvents

interface InputEvents

Interface representing input events in an application. Combines events related to mouse, keyboard, and pointers.

Keyboard

class Keyboard : KeyEvents

The Keyboard class provides event-based interaction for keyboard inputs. It implements the KeyEvents interface to handle various types of keyboard-related events such as key presses, releases, repetitions, and character inputs. These events are typically triggered by the Application interacting with the underlying system.

KeyEvent

data class KeyEvent(val type: KeyEventType, val key: Int, val name: String, val modifiers: Set<KeyModifier>)

Key event describes key events.

KeyEvents

interface KeyEvents

Interface for handling keyboard events. This interface provides access to events related to keyboard interactions such as key presses, releases, repetitions, and character inputs.

KeyEventType

enum KeyEventType : Enum<KeyEventType>

Represents the type of a key event in an application.

KeyModifier

enum KeyModifier : Enum<KeyModifier>

Represents key modifiers that can be used in combination with keyboard or mouse input.

KeyTracker

class KeyTracker(keyEvents: KeyEvents)

Tracks the keys currently pressed on the keyboard.

MouseButton

enum MouseButton : Enum<MouseButton>

Represents mouse buttons commonly used in interaction with graphical user interfaces.

MouseCursorHideMode

enum MouseCursorHideMode : Enum<MouseCursorHideMode>

MouseEvent

data class MouseEvent( val position: Vector2, val rotation: Vector2, val dragDisplacement: Vector2, val type: MouseEventType, val button: MouseButton, val modifiers: Set<KeyModifier>)

Represents a mouse event in a 2D GUI or application.

MouseEvents

interface MouseEvents

MouseEventType

enum MouseEventType : Enum<MouseEventType>

Represents the types of mouse events that can occur in the system.

MouseTracker

class MouseTracker(mouseEvents: MouseEvents)

Keeps track of which mouse buttons are currently pressed. Usage: val mt = MouseTracker(mouse), then read mt.pressedButtons. Replaces MouseEvents.pressedButtons.

Pointer

@JvmRecord

data class Pointer(val position: Vector2, val primary: Boolean, val timestamp: Long)

Pointers

class Pointers(application: () -> Application)

PresentationMode

enum PresentationMode : Enum<PresentationMode>

PresentationMode describes modes of frame presentation

ProduceAssetsEvent

@JvmRecord

data class ProduceAssetsEvent(val origin: Any, val program: Program, val assetMetadata: AssetMetadata)

Program

interface Program : InputEvents, ExtensionHost, Clock

Represents a program interface that combines input event handling, extension hosting, and clock functionalities. It provides common properties and methods for managing the lifecycle of a program, drawing operations, and asset management.

ProgramEvent

@JvmRecord

data class ProgramEvent(val type: ProgramEventType)

Represents an event occurring within a program.

ProgramEventType

enum ProgramEventType : Enum<ProgramEventType>

program event type

ProgramImplementation

open class ProgramImplementation(val suspend: Boolean = false) : Program

The Program class, this is where most user implementations start.

RequestAssetsEvent

@JvmRecord

data class RequestAssetsEvent(val origin: Any, val program: Program)

UnfocusBehaviour

enum UnfocusBehaviour : Enum<UnfocusBehaviour>

Specifies the behavior applied when an application window loses focus.

Window

interface Window

Represents a window with configurable properties and behavior.

WindowConfiguration

@JvmRecord

data class WindowConfiguration( val title: String = "OPENRNDR", val position: IntVector2? = null, val width: Int = 640, val height: Int = 480, val resizable: Boolean = false, val closable: Boolean = true, val alwaysOnTop: Boolean = false, val hideDecorations: Boolean = false, val multisample: WindowMultisample = WindowMultisample.Disabled)

WindowEvent

@JvmRecord

data class WindowEvent(val type: WindowEventType, val position: Vector2, val size: Vector2, val focused: Boolean)

window event message

WindowEventType

enum WindowEventType : Enum<WindowEventType>

Represents the types of events that can occur on a window.

WindowMultisample

sealed class WindowMultisample

WindowProgram

open class WindowProgram(val suspend: Boolean = false) : Program

Properties

applicationBaseFunc

var applicationBaseFunc: () -> ApplicationBase?

KEY_ARROW_DOWN

const val KEY_ARROW_DOWN: Int = 264

KEY_ARROW_LEFT

const val KEY_ARROW_LEFT: Int = 263

KEY_ARROW_RIGHT

const val KEY_ARROW_RIGHT: Int = 262

KEY_ARROW_UP

const val KEY_ARROW_UP: Int = 265

KEY_BACKSPACE

const val KEY_BACKSPACE: Int = 259

KEY_CAPSLOCK

const val KEY_CAPSLOCK: Int = 280

KEY_DELETE

const val KEY_DELETE: Int = 261

KEY_END

const val KEY_END: Int = 269

KEY_ENTER

const val KEY_ENTER: Int = 257

KEY_ESCAPE

const val KEY_ESCAPE: Int = 256

KEY_F1

const val KEY_F1: Int = 290

KEY_F10

const val KEY_F10: Int = 299

KEY_F11

const val KEY_F11: Int = 300

KEY_F12

const val KEY_F12: Int = 301

KEY_F2

const val KEY_F2: Int = 291

KEY_F3

const val KEY_F3: Int = 292

KEY_F4

const val KEY_F4: Int = 293

KEY_F5

const val KEY_F5: Int = 294

KEY_F6

const val KEY_F6: Int = 295

KEY_F7

const val KEY_F7: Int = 296

KEY_F8

const val KEY_F8: Int = 297

KEY_F9

const val KEY_F9: Int = 298

KEY_HOME

const val KEY_HOME: Int = 268

KEY_INSERT

const val KEY_INSERT: Int = 260

KEY_LEFT_SHIFT

const val KEY_LEFT_SHIFT: Int = 340

KEY_PAGE_DOWN

const val KEY_PAGE_DOWN: Int = 267

KEY_PAGE_UP

const val KEY_PAGE_UP: Int = 266

KEY_PRINT_SCREEN

const val KEY_PRINT_SCREEN: Int = 283

KEY_RIGHT_SHIFT

const val KEY_RIGHT_SHIFT: Int = 344

KEY_SPACEBAR

const val KEY_SPACEBAR: Int = 32

KEY_TAB

const val KEY_TAB: Int = 258

Functions

application

expect fun application(build: ApplicationBuilder.() -> Unit)

Constructs and configures an application using the provided builder block.

expect fun application(program: Program, configuration: Configuration = Configuration())

Configures and initializes an application using the specified program and optional configuration settings.

actual fun application(build: ApplicationBuilder.() -> Unit)

Creates and runs a synchronous OPENRNDR application using the provided ApplicationBuilder.

actual fun application(program: Program, configuration: Configuration)

Runs program as a synchronous application with the given configuration.

actual fun application(build: ApplicationBuilder.() -> Unit)

actual fun application(program: Program, configuration: Configuration)

Runs program as a synchronous application with the given configuration.

buildConfiguration

fun buildConfiguration(builder: Configuration.() -> Unit): Configuration

Convenience function for building a new Configuration.

drawImage

fun Program.drawImage( width: Int, height: Int, contentScale: Double? = null, format: ColorFormat = ColorFormat.RGBa, type: ColorType = defaultColorType(format), multisample: BufferMultisample? = null, drawFunction: Drawer.() -> Unit): ColorBuffer

Create an image ColorBuffer by drawing it

launch

fun launch(block: suspend () -> Unit)

launch

fun Dispatcher.launch(start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> Unit): Job

fun Program.launch( context: CoroutineContext = dispatcher, start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> Unit): Job

launch a coroutine in the Program context

namedTimestamp

expect fun Program.namedTimestamp(extension: String = "", path: String? = null): String

Generates a timestamped name for the program, optionally including a file extension and path.

actual fun Program.namedTimestamp(extension: String, path: String?): String

resourceText

expect fun resourceText(name: String, class: KClass<*> = Application::class): String

actual fun resourceText(name: String, class: KClass<*>): String

resourceUrl

expect fun resourceUrl(name: String, class: KClass<*> = Application::class): String

Resolves resource named name relative to class as a String based URL.

actual fun resourceUrl(name: String, class: KClass<*>): String

rootClassName

expect fun rootClassName(): String

actual fun rootClassName(): String

throttle

suspend fun throttle(timeMillis: Long)

window

fun Program.window(configuration: WindowConfiguration = WindowConfiguration(), init: suspend Program.() -> Unit): ApplicationWindow