enter lock-step mode

Enter lock-step mode, this method must only be called from the slave thread.

leave lock-step mode

Leave lock-step mode, this method must only be called from the slave thread.

start fixed frame time mode

Start the fixed frame time mode. In this mode the current time is increased by a fixed value every frame.

stop fixed frame time mode

Stop the fixed frame time mode.

notify arrival at sync point

This is the central sync point. Every thread will call this method at the start of a new frame to synchronize with the other lock-step frames. Once all threads have arrived, the master time will be advanced and the double-buffered message queues will be flipped.

add a message to be handled

Add a message to the producer queue, since we're using double buffering so we don't need thread-synchronization.

Reimplemented from Messaging::HandlerThreadBase.

cancel a pending message

Cancel a pending message from the producer queue. If the message is already in the consumer queue, then it's too late to cancel the message!

Reimplemented from Messaging::HandlerThreadBase.

wait for message to be handled

Wait for a message to be handled.

Reimplemented from Messaging::HandlerThreadBase.

this method runs in the thread context

The central message processing loop.

Reimplemented from Win360::Win360Thread.

attach a message handler

Attach a message handler to the port. This method may be called from any thread.

dynamically remove a message handler

Remove a message handler. This method may be called form any thread.

clear all attached message handlers

This clears all attached message handlers.

wait until handlers have been opened

Wait on the handlers-opened event (will be signalled by the ThreadOpenHandlers method.

open message handlers

Open attached message handlers. This method must be called at the start of the handler thread.

close message handlers

Close attached message handlers. This method must be called right before the handler thread shuts down.

open dynamically added handlers, and call DoWork() on all attached handlers

Do per-frame update of attached handlers. This will open handlers which have been added late, and call the DoWork() method on handlers from within the thread context.

update deferred messages, return true if at least one message has been handled

This checks every message in the deferred message array whether it has been handled yet, if yes, the message's actual handled flag will be set, and the message will be removed from the deferred handled array. If at least one message has been handled, the method will return true, if no message has been handled, the method returns false. If message have been handled, don't forget to call ThreadSignalMessageHandled() later!

clear leftover deferred messages

This clears any leftover deferred messages. Call right before shutdown of the handler thread.

handle messages in array, return true if at least one message has been handled

Handle all message in the provided message array. Supports batched and deferred messages. Calls ThreadHandleSingleMessage(). If at least one message has been handled, the method returns true.

handle a single message without deferred support, return if message has been handled

Handle a single message, called by ThreadHandleMessages(). Return true if message has been handled. This method MUST be called from ThreadHandleMessages(), since this method will not explicitely take the handlers array critical section.

signal message handled event (only call if at least one message has been handled)

Signal the message-handled flag. Call this method once per handler-loop if either ThreadUpdateDeferredMessages or ThreadHandleMessages returns true!

set thread name

Set the thread's name. To obtain the current thread's name from anywhere in the thread's execution context, call the static method Thread::GetMyThreadName().

get thread name

Get the thread's name. This is the vanilla method which returns the name member. To obtain the current thread's name from anywhere in the thread's execution context, call the static method Thread::GetMyThreadName().

start executing the thread code, returns when thread has actually started

Start the thread, this creates a Win32 thread and calls the static ThreadProc, which in turn calls the virtual DoWork() class of this object. The method waits for the thread to start and then returns.

request threading code to stop, returns when thread has actually finished

This stops the thread by signalling the stopRequestEvent and waits for the thread to actually quit. If the thread code runs in a loop it should use the IsStopRequested() method to see if the thread object wants it to shutdown. If so DoWork() should simply return.

Reimplemented in Jobs::TPWorkerThread.

return true if thread has been started

Returns true if the thread is currently running.

yield the thread (gives up current time slice)

The yield function is empty on Win32 and Xbox360.

set thread name from within thread context

Static method which sets the name of this thread. This is called from within ThreadProc. The string pointed to must remain valid until the thread is terminated!

obtain name of thread from within thread context

Static method to obtain the current thread name from anywhere in the thread's code.

get the thread ID of this thread

Static method which returns the ThreadId of this thread.

override this method if your thread loop needs a wakeup call before stopping

This method is called by Thread::Stop() after setting the stopRequest event and before waiting for the thread to stop. If your thread runs a loop and waits for jobs it may need an extra wakeup signal to stop waiting and check for the ThreadStopRequested() event. In this case, override this method and signal your event object.

Reimplemented in Jobs::TPWorkerThread, and Messaging::BlockingHandlerThread.

check if stop is requested, call from DoWork() to see if the thread proc should quit

If the derived DoWork() method is running in a loop it must regularly check if the process wants the thread to terminate by calling ThreadStopRequested() and simply return if the result is true. This will cause the thread to shut down.

get the current refcount

Return the current refcount of the object.

increment refcount by one

Increment the refcount of the object.

decrement refcount and destroy object if refcount is zero

Decrement the refcount and destroy object if refcount is zero.

get the class name

Get the class name of the object.

get the class FourCC code

Get the class FourCC of the object.

dump refcounting leaks, call at end of application (NEBULA3_DEBUG builds only!)

This method should be called as the very last before an application exits.