No OneTemporary
Actions

Authored By

Unknown

Size

12 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/util/events.cpp b/util/events.cpp
	index bf7cd277..90eb5158 100644
	--- a/util/events.cpp
	+++ b/util/events.cpp
	@@ -1,298 +1,301 @@
	#ifdef USE_SDL
	#include <SDL.h>
	#endif
	+#include <vector>
	#include "bitmap.h"
	#include "events.h"
	#include "exceptions/shutdown_exception.h"
	#include "configuration.h"
	#include "debug.h"
	#include "funcs.h"
	#include "thread.h"
	#include "init.h"
	#include "parameter.h"
	#include "input/keyboard.h"
	#include "input/joystick.h"
	#include "input/input-manager.h"

	+template <class Value> std::vector<Value> Util::Parameter<Value>::stack;
	+
	namespace Util{

	EventManager::EventManager():
	bufferKeys(false){
	}

	#ifdef USE_SDL
	static void handleKeyDown(Keyboard & keyboard, const SDL_Event & event){
	keyboard.press(event.key.keysym.sym, event.key.keysym.unicode);
	}

	static void handleKeyUp(Keyboard & keyboard, const SDL_Event & event){
	keyboard.release(event.key.keysym.sym);
	}

	static void handleJoystickButtonUp(Joystick * joystick, const SDL_Event & event){
	int device = event.jbutton.which;
	int button = event.jbutton.button;
	if (device == joystick->getDeviceId()){
	joystick->releaseButton(button);
	}
	}

	static void handleJoystickHat(Joystick * joystick, const SDL_Event & event){
	int device = event.jhat.which;
	int motion = event.jhat.value;
	/* should up/down control left/right -- flip these values? */
	#if WII
	const int axis_up_down = 0;
	const int axis_left_right = 1;
	const int up = 1;
	const int down = -1;
	const int left = -1;
	const int right = 1;
	#else
	const int axis_up_down = 1;
	const int axis_left_right = 0;
	const int up = -1;
	const int down = 1;
	const int left = -1;
	const int right = 1;
	#endif

	switch (motion){
	case SDL_HAT_CENTERED: break;
	case SDL_HAT_UP: joystick->axisMotion(axis_up_down, up); break;
	case SDL_HAT_DOWN: joystick->axisMotion(axis_up_down, down); break;
	case SDL_HAT_RIGHT: joystick->axisMotion(axis_left_right, right); break;
	case SDL_HAT_LEFT: joystick->axisMotion(axis_left_right, left); break;
	default: break;
	}
	}

	static void handleJoystickButtonDown(Joystick * joystick, const SDL_Event & event){
	int device = event.jbutton.which;
	int button = event.jbutton.button;
	if (device == joystick->getDeviceId()){
	joystick->pressButton(button);
	}
	}

	static void handleJoystickAxis(Joystick * joystick, const SDL_Event & event){
	int device = event.jaxis.which;
	int axis = event.jaxis.axis;
	int value = event.jaxis.value;
	if (device == joystick->getDeviceId()){
	joystick->axisMotion(axis, value);
	}
	}

	void EventManager::runSDL(Keyboard & keyboard, Joystick * joystick){
	keyboard.poll();
	if (joystick){
	joystick->poll();
	}
	SDL_Event event;
	while (SDL_PollEvent(&event) == 1){
	switch (event.type){
	case SDL_QUIT : {
	dispatch(CloseWindow);
	break;
	}
	case SDL_KEYDOWN : {
	handleKeyDown(keyboard, event);
	// dispatch(Key, event.key.keysym.sym);
	break;
	}
	case SDL_KEYUP : {
	handleKeyUp(keyboard, event);
	break;
	}
	case SDL_JOYBUTTONDOWN: {
	if (joystick != NULL){
	handleJoystickButtonDown(joystick, event);
	}
	break;
	}
	case SDL_JOYHATMOTION : {
	if (joystick != NULL){
	handleJoystickHat(joystick, event);
	}
	break;
	}
	case SDL_JOYBUTTONUP: {
	if (joystick != NULL){
	handleJoystickButtonUp(joystick, event);
	}
	break;
	}
	case SDL_JOYAXISMOTION: {
	if (joystick != NULL){
	handleJoystickAxis(joystick, event);
	}
	break;
	}
	case SDL_VIDEORESIZE : {
	int width = event.resize.w;
	int height = event.resize.h;
	/* to keep the perspective correct
	* 640/480 = 1.33333
	*/
	if (width > height){
	height = (int)((double) width / 1.3333333333);
	} else {
	width = (int)((double) height * 1.3333333333);
	}
	dispatch(ResizeScreen, width, height);
	break;
	}
	default : {
	break;
	}
	}
	}
	}
	#endif

	#ifdef USE_ALLEGRO
	void EventManager::runAllegro(Keyboard & keyboard, Joystick * joystick){
	keyboard.poll();
	}
	#endif

	void EventManager::run(Keyboard & keyboard, Joystick * joystick){
	#ifdef USE_SDL
	runSDL(keyboard, joystick);
	#elif USE_ALLEGRO
	runAllegro(keyboard, joystick);
	#endif
	}

	/* kill the program if the user requests */
	void EventManager::waitForThread(WaitThread & thread){
	// Keyboard dummy;
	while (!thread.isRunning()){
	try{
	/* input manager will run the event manager */
	InputManager::poll();
	// run(dummy);
	} catch (const ShutdownException & death){
	thread.kill();
	throw death;
	}
	Util::rest(10);
	}
	}

	EventManager::~EventManager(){
	}

	void EventManager::enableKeyBuffer(){
	bufferKeys = true;
	}

	void EventManager::disableKeyBuffer(){
	bufferKeys = false;
	}

	void EventManager::dispatch(Event type, int arg1){
	switch (type){
	case Key : {
	if (bufferKeys){
	keys.push_back(KeyType(arg1));
	}
	break;
	}
	default : {
	break;
	}
	}
	}

	void EventManager::dispatch(Event type, int arg1, int arg2){
	switch (type){
	case ResizeScreen : {
	Global::debug(1) << "Resizing screen to " << arg1 << ", " << arg2 << std::endl;
	if (Graphics::setGraphicsMode(0, arg1, arg2) == 0){
	Configuration::setScreenWidth(arg1);
	Configuration::setScreenHeight(arg2);
	}
	break;
	}
	default : break;
	}
	}

	void EventManager::dispatch(Event type){
	switch (type){
	case CloseWindow : {
	throw ShutdownException();
	}
	default : break;
	}
	}

	class LoopDone: public std::exception {
	public:
	LoopDone(){
	}

	~LoopDone() throw () {
	}
	};

	Logic::~Logic(){
	}

	Draw::~Draw(){
	}

	static void doStandardLoop(Logic & logic, Draw & draw){
	Global::speed_counter4 = 0;
	double runCounter = 0;
	try{
	while (!logic.done()){
	if (Global::speed_counter4 > 0){
	runCounter += logic.ticks(Global::speed_counter4);
	Global::speed_counter4 = 0;
	bool need_draw = false;
	while (runCounter >= 1.0){
	need_draw = true;
	InputManager::poll();
	runCounter -= 1;
	logic.run();

	if (Global::shutdown()){
	throw ShutdownException();
	}

	if (logic.done()){
	/* quit the loop immediately */
	throw LoopDone();
	}
	}

	if (need_draw){
	draw.draw();
	}
	}

	while (Global::speed_counter4 == 0){
	rest(1);
	}
	}
	} catch (const LoopDone & done){
	}
	}

	void standardLoop(Logic & logic, Draw & draw){
	/* if a screen already exists (because we have nested standardLoops) then
	* leave this parameter alone, otherwise set a new parameter.
	*/
	if (Parameter<Graphics::Bitmap*>::current() == NULL){
	Graphics::Bitmap screen(Graphics::getScreenBuffer());
	Parameter<Graphics::Bitmap*> use(&screen);
	doStandardLoop(logic, draw);
	} else {
	doStandardLoop(logic, draw);
	}
	}

	}
	diff --git a/util/thread.cpp b/util/thread.cpp
	index 15acc57b..c9b2a070 100644
	--- a/util/thread.cpp
	+++ b/util/thread.cpp
	@@ -1,209 +1,210 @@
	#include "thread.h"

	namespace Util{

	namespace Thread{

	LockObject::LockObject(){
	initializeLock(&lock);
	}

	void LockObject::acquire() const {
	/* quick hack to get around annoying constness */
	acquireLock((Lock*) &lock);
	}

	void LockObject::release() const {
	releaseLock((Lock*) &lock);
	}

	LockObject::~LockObject(){
	destroyLock(&lock);
	}

	ScopedLock::ScopedLock(const LockObject & lock):
	lock(lock){
	lock.acquire();
	}

	ScopedLock::~ScopedLock(){
	lock.release();
	}

	bool isUninitialized(Id thread){
	return thread == uninitializedValue;
	}

	#ifdef USE_SDL
	Id uninitializedValue = NULL;

	void initializeLock(Lock * lock){
	*lock = SDL_CreateMutex();
	}

	int acquireLock(Lock * lock){
	return SDL_LockMutex(*lock);
	}

	int releaseLock(Lock * lock){
	return SDL_UnlockMutex(*lock);
	}

	void destroyLock(Lock * lock){
	SDL_DestroyMutex(*lock);
	}

	void initializeSemaphore(Semaphore * semaphore, unsigned int value){
	*semaphore = SDL_CreateSemaphore(value);
	}

	void destroySemaphore(Semaphore * semaphore){
	SDL_DestroySemaphore(*semaphore);
	}

	void semaphoreDecrease(Semaphore * semaphore){
	SDL_SemWait(*semaphore);
	}

	void semaphoreIncrease(Semaphore * semaphore){
	SDL_SemPost(*semaphore);
	}

	bool createThread(Id * thread, void * attributes, ThreadFunction function, void * arg){
	*thread = SDL_CreateThread(function, arg);
	return *thread != NULL;
	}

	void joinThread(Id thread){
	SDL_WaitThread(thread, NULL);
	}

	void cancelThread(Id thread){
	#ifndef PS3
	SDL_KillThread(thread);
	#endif
	}

	#else
	Id uninitializedValue = 0;

	void initializeLock(Lock * lock){
	pthread_mutex_init(lock, NULL);
	}

	int acquireLock(Lock * lock){
	return pthread_mutex_lock(lock);
	}

	int releaseLock(Lock * lock){
	return pthread_mutex_unlock(lock);
	}

	void initializeSemaphore(Semaphore * semaphore, unsigned int value){
	sem_init(semaphore, 0, value);
	}

	void destroySemaphore(Semaphore * semaphore){
	/* nothing */
	}

	void semaphoreDecrease(Semaphore * semaphore){
	sem_wait(semaphore);
	}

	void semaphoreIncrease(Semaphore * semaphore){
	sem_post(semaphore);
	}

	bool createThread(Id * thread, void * attributes, ThreadFunction function, void * arg){
	return pthread_create(thread, (pthread_attr_t*) attributes, function, arg) == 0;
	}

	void joinThread(Id thread){
	pthread_join(thread, NULL);
	}

	void cancelThread(Id thread){
	/* FIXME: cancel is not implemented for libogc, find another way.
	* thread suspend/resume is there, though.
	*/
	#if !defined(WII)
	pthread_cancel(thread);
	#endif
	}

	void destroyLock(Lock * lock){
	/* nothing */
	}

	#endif

	}

	WaitThread::WaitThread():
	done(false){
	Thread::initializeLock(&doneLock);
	}

	WaitThread::WaitThread(Thread::ThreadFunction thread, void * arg){
	Thread::initializeLock(&doneLock);
	start(thread, arg);
	}

	static void * do_thread(void * arg){
	WaitThread * thread = (WaitThread *) arg;
	thread->doRun();
	return NULL;
	}

	void WaitThread::doRun(){
	this->function(this->arg);

	Thread::acquireLock(&doneLock);
	this->done = true;
	Thread::releaseLock(&doneLock);
	}

	void WaitThread::start(Thread::ThreadFunction thread, void * arg){
	done = false;
	this->arg = arg;
	this->function = thread;
	Thread::createThread(&this->thread, NULL, (Thread::ThreadFunction) do_thread, this);
	}

	bool WaitThread::isRunning(){
	Thread::acquireLock(&doneLock);
	bool what = done;
	Thread::releaseLock(&doneLock);
	return what;
	}

	void WaitThread::kill(){
	Thread::cancelThread(thread);
	Thread::joinThread(thread);
	}

	WaitThread::~WaitThread(){
	/* FIXME: Should we join the thread? */
	/* pthread_join(thread); */
	+ Thread::joinThread(thread);
	}

	ThreadBoolean::ThreadBoolean(volatile bool & what, Thread::Lock & lock):
	what(what),
	lock(lock){
	}

	bool ThreadBoolean::get(){
	Thread::acquireLock(&lock);
	bool b = what;
	Thread::releaseLock(&lock);
	return b;
	}

	void ThreadBoolean::set(bool value){
	Thread::acquireLock(&lock);
	what = value;
	Thread::releaseLock(&lock);
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jun 11, 11:00 AM (3 w, 5 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 68600
Default Alt Text: (12 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions