openrndr-application/org.openrndr

Package-level declarations

Types

Application

actual abstract class Application

This class is responsible for selecting and initializing the appropriate graphics backend.

expect abstract class Application

Application interface

actual abstract class Application

Application interface

ApplicationBase

actual abstract class ApplicationBase

This is accessible before finalizing the application in ApplicationBuilder.

expect abstract class ApplicationBase

This is accessible before finalizing the application in ApplicationBuilder.

actual abstract class ApplicationBase

This is accessible before finalizing the application in ApplicationBuilder.

ApplicationBuilder

abstract class ApplicationBuilder

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) : AutoCloseable

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

actual class Dispatcher : <ERROR CLASS> ERROR CLASS: Symbol not found for MainCoroutineDispatcher, <ERROR CLASS> ERROR CLASS: Symbol not found for Delay

expect class Dispatcher

actual class Dispatcher

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

Hit

enum Hit : Enum<Hit>

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 pointerID: Long, val position: Vector2, val pressure: Double)

PointerEvent

@JvmRecord

data class PointerEvent(val pointerID: Long, val position: Vector2, val displacement: Vector2, val pressure: Double)

PointerEvents

interface PointerEvents

The PointerEvents interface manages the lifecycle of pointer-related events such as pointer press, release, movement, and cancellation.

Pointers

class Pointers : PointerEvents

PointerTracker

class PointerTracker(pointerEvents: PointerEvents)

Tracks the state of pointer interactions in an 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 transparent: Boolean = false, val multisample: WindowMultisample = WindowMultisample.Disabled, val fullscreen: Fullscreen = Fullscreen.DISABLED, val hideMouseCursor: Boolean = false, val relativeMouseCoordinates: Boolean = false, val utilityWindow: Boolean = false, val display: Display? = null, val unfocusBehaviour: UnfocusBehaviour = UnfocusBehaviour.NORMAL)

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

val KEY_ARROW_DOWN: Int

KEY_ARROW_LEFT

val KEY_ARROW_LEFT: Int

KEY_ARROW_RIGHT

val KEY_ARROW_RIGHT: Int

KEY_ARROW_UP

val KEY_ARROW_UP: Int

KEY_BACKSPACE

val KEY_BACKSPACE: Int

KEY_CAPSLOCK

val KEY_CAPSLOCK: Int

val KEY_DELETE: Int

val KEY_END: Int

val KEY_ENTER: Int

val KEY_ESCAPE: Int

val KEY_F1: Int

val KEY_F10: Int

val KEY_F11: Int

val KEY_F12: Int

val KEY_F2: Int

val KEY_F3: Int

val KEY_F4: Int

val KEY_F5: Int

val KEY_F6: Int

val KEY_F7: Int

val KEY_F8: Int

val KEY_F9: Int

val KEY_HOME: Int

val KEY_INSERT: Int

val KEY_LEFT_CONTROL: Int

KEY_LEFT_SHIFT

val KEY_LEFT_SHIFT: Int

KEY_PAGE_DOWN

val KEY_PAGE_DOWN: Int

KEY_PAGE_UP

val KEY_PAGE_UP: Int

KEY_PRINT_SCREEN

val KEY_PRINT_SCREEN: Int

KEY_RIGHT_CONTROL

val KEY_RIGHT_CONTROL: Int

KEY_RIGHT_SHIFT

val KEY_RIGHT_SHIFT: Int

KEY_SPACEBAR

val KEY_SPACEBAR: Int

KEY_TAB

val KEY_TAB: Int

KEYNAME_ARROW_DOWN

const val KEYNAME_ARROW_DOWN: String

KEYNAME_ARROW_LEFT

const val KEYNAME_ARROW_LEFT: String

KEYNAME_ARROW_RIGHT

const val KEYNAME_ARROW_RIGHT: String

KEYNAME_ARROW_UP

const val KEYNAME_ARROW_UP: String

KEYNAME_BACKSPACE

const val KEYNAME_BACKSPACE: String

KEYNAME_CAPSLOCK

const val KEYNAME_CAPSLOCK: String

KEYNAME_DELETE

const val KEYNAME_DELETE: String

KEYNAME_END

const val KEYNAME_END: String

KEYNAME_ENTER

const val KEYNAME_ENTER: String

KEYNAME_ESCAPE

const val KEYNAME_ESCAPE: String

KEYNAME_F1

const val KEYNAME_F1: String

KEYNAME_F10

const val KEYNAME_F10: String

KEYNAME_F11

const val KEYNAME_F11: String

KEYNAME_F12

const val KEYNAME_F12: String

KEYNAME_F2

const val KEYNAME_F2: String

KEYNAME_F3

const val KEYNAME_F3: String

KEYNAME_F4

const val KEYNAME_F4: String

KEYNAME_F5

const val KEYNAME_F5: String

KEYNAME_F6

const val KEYNAME_F6: String

KEYNAME_F7

const val KEYNAME_F7: String

KEYNAME_F8

const val KEYNAME_F8: String

KEYNAME_F9

const val KEYNAME_F9: String

KEYNAME_HOME

const val KEYNAME_HOME: String

KEYNAME_INSERT

const val KEYNAME_INSERT: String

KEYNAME_LEFT_ALT

const val KEYNAME_LEFT_ALT: String

KEYNAME_LEFT_CONTROL

const val KEYNAME_LEFT_CONTROL: String

KEYNAME_LEFT_SHIFT

const val KEYNAME_LEFT_SHIFT: String

KEYNAME_LEFT_SUPER

const val KEYNAME_LEFT_SUPER: String

KEYNAME_PAGE_DOWN

const val KEYNAME_PAGE_DOWN: String

KEYNAME_PAGE_UP

const val KEYNAME_PAGE_UP: String

KEYNAME_PRINT_SCREEN

const val KEYNAME_PRINT_SCREEN: String

KEYNAME_RIGHT_ALT

const val KEYNAME_RIGHT_ALT: String

KEYNAME_RIGHT_CONTROL

const val KEYNAME_RIGHT_CONTROL: String

KEYNAME_RIGHT_SHIFT

const val KEYNAME_RIGHT_SHIFT: String

KEYNAME_RIGHT_SUPER

const val KEYNAME_RIGHT_SUPER: String

KEYNAME_SPACEBAR

const val KEYNAME_SPACEBAR: String

KEYNAME_TAB

const val KEYNAME_TAB: String

logger

val logger: KLogger

Functions

application

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

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

Runs program as a synchronous application with the given configuration.

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.

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: ERROR CLASS: Symbol not found for CoroutineStart = CoroutineStart.DEFAULT, block: suspend ERROR CLASS: Symbol not found for CoroutineScope.() -> Unit): ERROR CLASS: Symbol not found for Job

fun Program.launch(context: ERROR CLASS: Symbol not found for CoroutineContext = dispatcher, start: ERROR CLASS: Symbol not found for CoroutineStart = CoroutineStart.DEFAULT, block: suspend ERROR CLASS: Symbol not found for CoroutineScope.() -> Unit): ERROR CLASS: Symbol not found for Job

launch a coroutine in the Program context

namedTimestamp

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

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

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

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

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

resourceUrl

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

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

actual fun rootClassName(): String

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