korge/korlibs.render/GameWindowCoroutineDispatcher

GameWindowCoroutineDispatcher

class GameWindowCoroutineDispatcher(var nowProvider: () -> TimeSpan = { PerformanceCounter.reference }, var fast: Boolean = false) : CoroutineDispatcher, Delay, Closeable

Constructors

GameWindowCoroutineDispatcher

constructor(nowProvider: () -> TimeSpan = { PerformanceCounter.reference }, fast: Boolean = false)

Types

object Companion

class TimedTask(val time: TimeSpan, val continuation: CancellableContinuation<Unit>?, val callback: Runnable?)

Properties

var fast: Boolean

val hasMore: Boolean

open override val key: CoroutineContext.Key<*>

val lock: NonRecursiveLock

maxAllocatedTimeForTasksPerFrame

var maxAllocatedTimeForTasksPerFrame: TimeSpan?

Allows to configure how much time per frame is available to execute pending tasks, despite time available in the frame. When not set it uses the remaining available time in frame

var nowProvider: () -> TimeSpan

var tasksTime: Duration

var timedTasksTime: Duration

tooManyCallbacksLogger

val tooManyCallbacksLogger: Logger

Functions

open override fun close()

open suspend fun ~~delay~~(time: Long)

open override fun dispatch(context: CoroutineContext, block: Runnable)

open override fun dispatchYield(context: CoroutineContext, block: Runnable)

fun executePending(availableTime: TimeSpan)

open override fun <R> fold(initial: R, operation: (R, CoroutineContext.Element) -> R): R

open operator override fun <E : CoroutineContext.Element> get(key: CoroutineContext.Key<E>): E?

fun hasTasks(): Boolean

informTooManyCallbacksToHandleInThisFrame

fun informTooManyCallbacksToHandleInThisFrame(elapsedTime: TimeSpan, availableTime: TimeSpan, processedTimedTasks: Int, processedTasks: Int)

interceptContinuation

override fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T>

invokeOnTimeout

open override fun invokeOnTimeout(timeMillis: Long, block: Runnable, context: CoroutineContext): DisposableHandle

isDispatchNeeded

open fun isDispatchNeeded(context: CoroutineContext): Boolean

limitedParallelism

open fun limitedParallelism(parallelism: Int): CoroutineDispatcher

open override fun minusKey(key: CoroutineContext.Key<*>): CoroutineContext

fun now(): Duration

open operator fun plus(context: CoroutineContext): CoroutineContext

operator fun ~~plus~~(other: CoroutineDispatcher): CoroutineDispatcher

fun queue(block: () -> Unit)

fun queue(block: Runnable?)

fun <T> queueBlocking(block: () -> T): T

releaseInterceptedContinuation

override fun releaseInterceptedContinuation(continuation: Continuation<*>)

scheduleResumeAfterDelay

open override fun scheduleResumeAfterDelay(timeMillis: Long, continuation: CancellableContinuation<Unit>)

fun scheduleResumeAfterDelay(time: TimeSpan, continuation: CancellableContinuation<Unit>)

open override fun toString(): String