korge/korlibs.render/GameWindow

GameWindow

open class GameWindow : BaseEventListener, DialogInterfaceProvider, DeviceDimensionsProvider, CoroutineContext.Element, AGWindow, GameWindowConfig, Extra

A GameWindow represents a window, canvas or headless virtual frame where a game is displayed and can receive user events, it provides:

Updating and Rendering:

An EventLoop and a coroutineDispatcher where run code in a single thread like on JavaScript
Provides an onUpdateEvent that will be executed in the EventLoop at a fixed rate determined by fps used for updating the game, and having a lock to prevent rendering while running
Provides an onRenderEvent that will be executed in the Rendering thread at vsync or whenever a rendering is required. It has a lock to prevent executing at the same time as the onUpdateEvent.
If needing to update the game state outside the provided EventLoop, you can use the updateRenderLock function

Events:

It implements the EventListener interface.
Dispatches Window and User Input events:
Update and rendering events: UpdateEvent, RenderEvent
Window/App lifecycle event: PauseEvent, ResumeEvent, StopEvent, InitEvent, DestroyEvent, DisposeEvent, FullScreenEvent, ReshapeEvent
Input events: KeyEvent, MouseEvent, GestureEvent, DropFileEvent

Window properties:

title, icon, cursor, width, height, preferredFps, fullscreen, visible, bgcolor, quality, alwaysOnTop

Dialogs DialogInterface:

Virtual Keyboard:

showSoftKeyboard, hideSoftKeyboard

Device Dimensions provider:

devicePixelRatio, pixelsPerInch, pixelsPerCm

Inheritors

BaseAndroidGameWindow

Constructors

GameWindow

constructor()

Types

CoroutineKey

object CoroutineKey : CoroutineContext.Key<GameWindow>

Cursor

enum Cursor : Enum<GameWindow.Cursor> , GameWindow.ICursor

CustomCursor

data class CustomCursor(val shape: Shape, val name: String = "custom") : GameWindow.ICursor, Extra

HapticFeedbackKind

enum HapticFeedbackKind : Enum<GameWindow.HapticFeedbackKind>

ICursor

interface ICursor

MenuItem

data class MenuItem(val text: String?, val enabled: Boolean = true, val children: List<GameWindow.MenuItem>? = null, val action: () -> Unit = {})

MenuItemBuilder

class MenuItemBuilder(text: String? = null, enabled: Boolean = true, action: () -> Unit = {})

Quality

enum Quality : Enum<GameWindow.Quality> , Quality

Describes if the rendering should focus on performance or quality. PERFORMANCE will use lower resolutions, while QUALITY will use the devicePixelRatio to render high quality images.

Properties

open override val ag: AG

alwaysOnTop

open var alwaysOnTop: Boolean

androidContextAny

open val androidContextAny: Any?

bgcolor

open var bgcolor: RGBA

bufferHeight

open val bufferHeight: Int

bufferWidth

open val bufferWidth: Int

computedPixelRatio

open val computedPixelRatio: Double

continuousRenderMode

open var continuousRenderMode: Boolean

coroutineDispatcher

open val coroutineDispatcher: GameWindowCoroutineDispatcher

counterTimePerFrame

val counterTimePerFrame: TimeSpan

cursor

open var cursor: GameWindow.ICursor

debug

open var debug: Boolean

debugComponent

open val debugComponent: Any? = null

devicePixelRatio

open val devicePixelRatio: Double

dialogInterface

open override val dialogInterface: DialogInterface

eventListenerParent

var eventListenerParent: BaseEventListener?

exitCode

var exitCode: Int

exitProcessOnClose

var exitProcessOnClose: Boolean

extra

open override var extra: ExtraType

fps

open var fps: Int

fullscreen

open var fullscreen: Boolean

gamepadEmitter

val gamepadEmitter: GamepadInfoEmitter

gamePadTime

var gamePadTime: TimeSpan

gameWindowAndroidContext

val GameWindow.gameWindowAndroidContext: Context

gameWindowAndroidContextOrNull

val GameWindow.gameWindowAndroidContextOrNull: Context?

hapticFeedbackGenerateSupport

open val hapticFeedbackGenerateSupport: Boolean

height

open val height: Int = 0

icon

open var icon: Bitmap?

isSoftKeyboardVisible

open val isSoftKeyboardVisible: Boolean

keepScreenOn

open var keepScreenOn: Boolean

Flag to keep the screen on, even when there is no user input and the user is idle

key

open override val key: CoroutineContext.Key<*>

mustTriggerRender

val mustTriggerRender: Boolean

myCoroutineDispatcher

open val myCoroutineDispatcher: SyncEventLoopCoroutineDispatcher

onContinuousRenderModeUpdated

var onContinuousRenderModeUpdated: (Boolean) -> Unit?

onDebugChanged

val onDebugChanged: Signal<Boolean>

onDebugEnabled

val onDebugEnabled: Signal<Unit>

pixelsPerCm

open val pixelsPerCm: Double

Approximate on iOS

pixelsPerInch

open val pixelsPerInch: Double

Approximate on iOS

pixelsPerLogicalInchRatio

open val pixelsPerLogicalInchRatio: Double

preferredFps

open var preferredFps: Int

quality

open override var quality: GameWindow.Quality

renderTime

var renderTime: Duration

running

var running: Boolean

timePerFrame

val timePerFrame: TimeSpan

title

open var title: String

updatedSinceFrame

var updatedSinceFrame: Int

updateTime

var updateTime: Duration

visible

open var visible: Boolean

vsync

open var vsync: Boolean

width

open val width: Int = 0

Functions

alert

suspend fun DialogInterfaceProvider.alert(message: String)

alertError

suspend fun DialogInterfaceProvider.alertError(e: Throwable)

browse

suspend fun DialogInterfaceProvider.browse(url: URL)

clearEvents

fun clearEvents()

fun <T : BEvent> clearEvents(type: EventType<T>)

clipboardRead

open suspend fun clipboardRead(): ClipboardData?

clipboardWrite

open suspend fun clipboardWrite(data: ClipboardData)

open fun close(exitCode: Int = 0)

computeDisplayRefreshRate

open fun computeDisplayRefreshRate(): Int

configure

fun GameWindow.configure(size: Size, title: String? = "GameWindow", icon: Bitmap? = null, fullscreen: Boolean? = null, bgcolor: RGBA = Colors.BLACK)

confirm

suspend fun DialogInterfaceProvider.confirm(message: String): Boolean

dispatch

override fun <T : BEvent> dispatch(event: T): Boolean

override fun <T : BEvent> dispatch(type: EventType<T>, event: T, result: EventResult?): Boolean

open override fun <T : BEvent> dispatch(type: EventType<T>, event: T, result: EventResult?, up: Boolean, down: Boolean): Boolean

Dispatched a event of type that will execute all the handlers registered with onEvents in this object and its children.

dispatchChildren

open fun <T : BEvent> dispatchChildren(type: EventType<T>, event: T, result: EventResult?)

dispatchDestroyEvent

fun dispatchDestroyEvent(): Boolean

dispatchDisposeEvent

fun dispatchDisposeEvent(): Boolean

dispatchDown

open fun <T : BEvent> dispatchDown(type: EventType<T>, event: T, result: EventResult? = null): Boolean

dispatchDown

fun <T : BEvent> EventListener.dispatchDown(event: T): Boolean

dispatchDropfileEvent

fun dispatchDropfileEvent(type: DropFileEvent.Type, files: List<VfsFile>?): Boolean

dispatchFullscreenEvent

fun dispatchFullscreenEvent(fullscreen: Boolean): Boolean

dispatchGamepadUpdateAdd

fun dispatchGamepadUpdateAdd(info: GamepadInfo)

dispatchGamepadUpdateEnd

fun dispatchGamepadUpdateEnd(out: IntArrayList = IntArrayList()): IntArrayList

Triggers an update envent and potential CONNECTED/DISCONNECTED events.

dispatchGamepadUpdateStart

fun dispatchGamepadUpdateStart()

dispatchInitEvent

fun dispatchInitEvent(): Boolean

dispatchKeyEvent

fun dispatchKeyEvent(type: KeyEvent.Type, id: Int, character: Char, key: Key, keyCode: Int, str: String? = null): Boolean

dispatchKeyEventDownUp

fun dispatchKeyEventDownUp(id: Int, character: Char, key: Key, keyCode: Int, str: String? = null): Boolean

dispatchKeyEventEx

fun dispatchKeyEventEx(type: KeyEvent.Type, id: Int, character: Char, key: Key, keyCode: Int, shift: Boolean = this.shift, ctrl: Boolean = this.ctrl, alt: Boolean = this.alt, meta: Boolean = this.meta, str: String? = null): Boolean

dispatchMouseEvent

fun dispatchMouseEvent(type: MouseEvent.Type, id: Int, x: Int, y: Int, button: MouseButton, buttons: Int = this.mouseButtons, scrollDeltaX: Float = this.scrollDeltaX, scrollDeltaY: Float = this.scrollDeltaY, scrollDeltaZ: Float = this.scrollDeltaZ, isShiftDown: Boolean = this.shift, isCtrlDown: Boolean = this.ctrl, isAltDown: Boolean = this.alt, isMetaDown: Boolean = this.meta, scaleCoords: Boolean = this.scaleCoords, simulateClickOnUp: Boolean = false, scrollDeltaMode: MouseEvent.ScrollDeltaMode = MouseEvent.ScrollDeltaMode.LINE)

dispatchNewRenderEvent

fun dispatchNewRenderEvent()

dispatchParent