From 832904dce14bd1d53f16cce58b947400b3938a89 Mon Sep 17 00:00:00 2001 From: Xawotihs Date: Sat, 23 Apr 2011 21:30:36 +0000 Subject: [PATCH] - Defined keys translation for SDL config - Added boost thread files, that fixes all the threading/compiling/linking problems on Android ... - Added opengles 1.1 code, there are still some bugs I need to tackle ... and I should realy split this file now !!! - Added Android debug traces - Hardcoded resources to "/sdcard/Wagic/Res" for the moment on Android - Added a wagic SDL project for desktop, and the related SDL frontend used for Android. This frontend is currently mostly desktop based, it needs some work to be fully useable with touch and gesture on Android. --- Boost/lib/pthread/once.cpp | 51 +++ Boost/lib/pthread/thread.cpp | 601 ++++++++++++++++++++++++++++ Boost/lib/pthread/timeconv.inl | 133 ++++++ JGE/include/DebugRoutines.h | 25 +- JGE/include/JGE.h | 6 +- JGE/include/JTypes.h | 17 +- JGE/src/JFileSystem.cpp | 2 + JGE/src/SDLmain.cpp | 448 +++++++++++++++++++++ JGE/src/pc/JGfx.cpp | 579 +++++++++++++++++++++++++-- projects/mtg/Android/jni/Android.mk | 4 +- projects/mtg/src/TranslateKeys.cpp | 11 +- projects/mtg/wagic-SDL.pro | 389 ++++++++++++++++++ 12 files changed, 2216 insertions(+), 50 deletions(-) create mode 100644 Boost/lib/pthread/once.cpp create mode 100644 Boost/lib/pthread/thread.cpp create mode 100644 Boost/lib/pthread/timeconv.inl create mode 100644 JGE/src/SDLmain.cpp create mode 100644 projects/mtg/wagic-SDL.pro diff --git a/Boost/lib/pthread/once.cpp b/Boost/lib/pthread/once.cpp new file mode 100644 index 000000000..6e3722a8e --- /dev/null +++ b/Boost/lib/pthread/once.cpp @@ -0,0 +1,51 @@ +// Copyright (C) 2007 Anthony Williams +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#define __STDC_CONSTANT_MACROS +#include +#include +#include +#include + +namespace boost +{ + namespace detail + { + BOOST_THREAD_DECL boost::uintmax_t once_global_epoch=UINTMAX_C(~0); + BOOST_THREAD_DECL pthread_mutex_t once_epoch_mutex=PTHREAD_MUTEX_INITIALIZER; + BOOST_THREAD_DECL pthread_cond_t once_epoch_cv = PTHREAD_COND_INITIALIZER; + + namespace + { + pthread_key_t epoch_tss_key; + pthread_once_t epoch_tss_key_flag=PTHREAD_ONCE_INIT; + + extern "C" void delete_epoch_tss_data(void* data) + { + free(data); + } + + extern "C" void create_epoch_tss_key() + { + BOOST_VERIFY(!pthread_key_create(&epoch_tss_key,delete_epoch_tss_data)); + } + + } + + boost::uintmax_t& get_once_per_thread_epoch() + { + BOOST_VERIFY(!pthread_once(&epoch_tss_key_flag,create_epoch_tss_key)); + void* data=pthread_getspecific(epoch_tss_key); + if(!data) + { + data=malloc(sizeof(boost::uintmax_t)); + BOOST_VERIFY(!pthread_setspecific(epoch_tss_key,data)); + *static_cast(data)=UINTMAX_C(~0); + } + return *static_cast(data); + } + } + +} diff --git a/Boost/lib/pthread/thread.cpp b/Boost/lib/pthread/thread.cpp new file mode 100644 index 000000000..4ff40a90b --- /dev/null +++ b/Boost/lib/pthread/thread.cpp @@ -0,0 +1,601 @@ +// Copyright (C) 2001-2003 +// William E. Kempf +// Copyright (C) 2007-8 Anthony Williams +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include + +#include +#include +#include +#include +#include +#include +#include +#ifdef __linux__ +#include +#elif defined(__APPLE__) || defined(__FreeBSD__) +#include +#include +#elif defined BOOST_HAS_UNISTD_H +#include +#endif + +#include "timeconv.inl" + +namespace boost +{ + namespace detail + { + thread_data_base::~thread_data_base() + {} + + struct thread_exit_callback_node + { + boost::detail::thread_exit_function_base* func; + thread_exit_callback_node* next; + + thread_exit_callback_node(boost::detail::thread_exit_function_base* func_, + thread_exit_callback_node* next_): + func(func_),next(next_) + {} + }; + + namespace + { + boost::once_flag current_thread_tls_init_flag=BOOST_ONCE_INIT; + pthread_key_t current_thread_tls_key; + + extern "C" + { + void tls_destructor(void* data) + { + boost::detail::thread_data_base* thread_info=static_cast(data); + if(thread_info) + { + while(!thread_info->tss_data.empty() || thread_info->thread_exit_callbacks) + { + while(thread_info->thread_exit_callbacks) + { + detail::thread_exit_callback_node* const current_node=thread_info->thread_exit_callbacks; + thread_info->thread_exit_callbacks=current_node->next; + if(current_node->func) + { + (*current_node->func)(); + delete current_node->func; + } + delete current_node; + } + for(std::map::iterator next=thread_info->tss_data.begin(), + current, + end=thread_info->tss_data.end(); + next!=end;) + { + current=next; + ++next; + if(current->second.func && (current->second.value!=0)) + { + (*current->second.func)(current->second.value); + } + thread_info->tss_data.erase(current); + } + } + thread_info->self.reset(); + } + } + } + + + void create_current_thread_tls_key() + { + BOOST_VERIFY(!pthread_key_create(¤t_thread_tls_key,&tls_destructor)); + } + } + + boost::detail::thread_data_base* get_current_thread_data() + { + boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key); + return (boost::detail::thread_data_base*)pthread_getspecific(current_thread_tls_key); + } + + void set_current_thread_data(detail::thread_data_base* new_data) + { + boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key); + BOOST_VERIFY(!pthread_setspecific(current_thread_tls_key,new_data)); + } + } + + namespace + { + extern "C" + { + void* thread_proxy(void* param) + { + boost::detail::thread_data_ptr thread_info = static_cast(param)->self; + thread_info->self.reset(); + detail::set_current_thread_data(thread_info.get()); + try + { + thread_info->run(); + } + catch(thread_interrupted const&) + { + } +// Removed as it stops the debugger identifying the cause of the exception +// Unhandled exceptions still cause the application to terminate +// catch(...) +// { +// std::terminate(); +// } + + detail::tls_destructor(thread_info.get()); + detail::set_current_thread_data(0); + boost::lock_guard lock(thread_info->data_mutex); + thread_info->done=true; + thread_info->done_condition.notify_all(); + return 0; + } + } + + struct externally_launched_thread: + detail::thread_data_base + { + externally_launched_thread() + { + interrupt_enabled=false; + } + + void run() + {} + + private: + externally_launched_thread(externally_launched_thread&); + void operator=(externally_launched_thread&); + }; + + detail::thread_data_base* make_external_thread_data() + { + detail::thread_data_base* const me(new externally_launched_thread()); + me->self.reset(me); + set_current_thread_data(me); + return me; + } + + + detail::thread_data_base* get_or_make_current_thread_data() + { + detail::thread_data_base* current_thread_data(detail::get_current_thread_data()); + if(!current_thread_data) + { + current_thread_data=make_external_thread_data(); + } + return current_thread_data; + } + + } + + + thread::thread() + {} + + void thread::start_thread() + { + thread_info->self=thread_info; + int const res = pthread_create(&thread_info->thread_handle, 0, &thread_proxy, thread_info.get()); + if (res != 0) + { + thread_info->self.reset(); + boost::throw_exception(thread_resource_error()); + } + } + + thread::~thread() + { + detach(); + } + + detail::thread_data_ptr thread::get_thread_info BOOST_PREVENT_MACRO_SUBSTITUTION () const + { + return thread_info; + } + + void thread::join() + { + detail::thread_data_ptr const local_thread_info=(get_thread_info)(); + if(local_thread_info) + { + bool do_join=false; + + { + unique_lock lock(local_thread_info->data_mutex); + while(!local_thread_info->done) + { + local_thread_info->done_condition.wait(lock); + } + do_join=!local_thread_info->join_started; + + if(do_join) + { + local_thread_info->join_started=true; + } + else + { + while(!local_thread_info->joined) + { + local_thread_info->done_condition.wait(lock); + } + } + } + if(do_join) + { + void* result=0; + BOOST_VERIFY(!pthread_join(local_thread_info->thread_handle,&result)); + lock_guard lock(local_thread_info->data_mutex); + local_thread_info->joined=true; + local_thread_info->done_condition.notify_all(); + } + + if(thread_info==local_thread_info) + { + thread_info.reset(); + } + } + } + + bool thread::timed_join(system_time const& wait_until) + { + detail::thread_data_ptr const local_thread_info=(get_thread_info)(); + if(local_thread_info) + { + bool do_join=false; + + { + unique_lock lock(local_thread_info->data_mutex); + while(!local_thread_info->done) + { + if(!local_thread_info->done_condition.timed_wait(lock,wait_until)) + { + return false; + } + } + do_join=!local_thread_info->join_started; + + if(do_join) + { + local_thread_info->join_started=true; + } + else + { + while(!local_thread_info->joined) + { + local_thread_info->done_condition.wait(lock); + } + } + } + if(do_join) + { + void* result=0; + BOOST_VERIFY(!pthread_join(local_thread_info->thread_handle,&result)); + lock_guard lock(local_thread_info->data_mutex); + local_thread_info->joined=true; + local_thread_info->done_condition.notify_all(); + } + + if(thread_info==local_thread_info) + { + thread_info.reset(); + } + } + return true; + } + + bool thread::joinable() const + { + return (get_thread_info)(); + } + + + void thread::detach() + { + detail::thread_data_ptr local_thread_info; + thread_info.swap(local_thread_info); + + if(local_thread_info) + { + lock_guard lock(local_thread_info->data_mutex); + if(!local_thread_info->join_started) + { + BOOST_VERIFY(!pthread_detach(local_thread_info->thread_handle)); + local_thread_info->join_started=true; + local_thread_info->joined=true; + } + } + } + + namespace this_thread + { + + void sleep(const system_time& st) + { + detail::thread_data_base* const thread_info=detail::get_current_thread_data(); + + if(thread_info) + { + unique_lock lk(thread_info->sleep_mutex); + while(thread_info->sleep_condition.timed_wait(lk,st)); + } + else + { + xtime const xt=get_xtime(st); + + for (int foo=0; foo < 5; ++foo) + { +# if defined(BOOST_HAS_PTHREAD_DELAY_NP) + timespec ts; + to_timespec_duration(xt, ts); + BOOST_VERIFY(!pthread_delay_np(&ts)); +# elif defined(BOOST_HAS_NANOSLEEP) + timespec ts; + to_timespec_duration(xt, ts); + + // nanosleep takes a timespec that is an offset, not + // an absolute time. + nanosleep(&ts, 0); +# else + mutex mx; + mutex::scoped_lock lock(mx); + condition cond; + cond.timed_wait(lock, xt); +# endif + xtime cur; + xtime_get(&cur, TIME_UTC); + if (xtime_cmp(xt, cur) <= 0) + return; + } + } + } + + void yield() + { +# if defined(BOOST_HAS_SCHED_YIELD) + BOOST_VERIFY(!sched_yield()); +# elif defined(BOOST_HAS_PTHREAD_YIELD) + BOOST_VERIFY(!pthread_yield()); +# else + xtime xt; + xtime_get(&xt, TIME_UTC); + sleep(xt); +# endif + } + } + + unsigned thread::hardware_concurrency() + { +#if defined(PTW32_VERSION) || defined(__hpux) + return pthread_num_processors_np(); +#elif defined(__APPLE__) || defined(__FreeBSD__) + int count; + size_t size=sizeof(count); + return sysctlbyname("hw.ncpu",&count,&size,NULL,0)?0:count; +#elif defined(BOOST_HAS_UNISTD_H) && defined(_SC_NPROCESSORS_ONLN) + int const count=sysconf(_SC_NPROCESSORS_ONLN); + return (count>0)?count:0; +#elif defined(_GNU_SOURCE) + return get_nprocs(); +#else + return 0; +#endif + } + + thread::id thread::get_id() const + { + detail::thread_data_ptr const local_thread_info=(get_thread_info)(); + if(local_thread_info) + { + return id(local_thread_info); + } + else + { + return id(); + } + } + + void thread::interrupt() + { + detail::thread_data_ptr const local_thread_info=(get_thread_info)(); + if(local_thread_info) + { + lock_guard lk(local_thread_info->data_mutex); + local_thread_info->interrupt_requested=true; + if(local_thread_info->current_cond) + { + BOOST_VERIFY(!pthread_cond_broadcast(local_thread_info->current_cond)); + } + } + } + + bool thread::interruption_requested() const + { + detail::thread_data_ptr const local_thread_info=(get_thread_info)(); + if(local_thread_info) + { + lock_guard lk(local_thread_info->data_mutex); + return local_thread_info->interrupt_requested; + } + else + { + return false; + } + } + + thread::native_handle_type thread::native_handle() + { + detail::thread_data_ptr const local_thread_info=(get_thread_info)(); + if(local_thread_info) + { + lock_guard lk(local_thread_info->data_mutex); + return local_thread_info->thread_handle; + } + else + { + return pthread_t(); + } + } + + + + namespace this_thread + { + thread::id get_id() + { + boost::detail::thread_data_base* const thread_info=get_or_make_current_thread_data(); + return thread::id(thread_info?thread_info->shared_from_this():detail::thread_data_ptr()); + } + + void interruption_point() + { + boost::detail::thread_data_base* const thread_info=detail::get_current_thread_data(); + if(thread_info && thread_info->interrupt_enabled) + { + lock_guard lg(thread_info->data_mutex); + if(thread_info->interrupt_requested) + { + thread_info->interrupt_requested=false; + throw thread_interrupted(); + } + } + } + + bool interruption_enabled() + { + boost::detail::thread_data_base* const thread_info=detail::get_current_thread_data(); + return thread_info && thread_info->interrupt_enabled; + } + + bool interruption_requested() + { + boost::detail::thread_data_base* const thread_info=detail::get_current_thread_data(); + if(!thread_info) + { + return false; + } + else + { + lock_guard lg(thread_info->data_mutex); + return thread_info->interrupt_requested; + } + } + + disable_interruption::disable_interruption(): + interruption_was_enabled(interruption_enabled()) + { + if(interruption_was_enabled) + { + detail::get_current_thread_data()->interrupt_enabled=false; + } + } + + disable_interruption::~disable_interruption() + { + if(detail::get_current_thread_data()) + { + detail::get_current_thread_data()->interrupt_enabled=interruption_was_enabled; + } + } + + restore_interruption::restore_interruption(disable_interruption& d) + { + if(d.interruption_was_enabled) + { + detail::get_current_thread_data()->interrupt_enabled=true; + } + } + + restore_interruption::~restore_interruption() + { + if(detail::get_current_thread_data()) + { + detail::get_current_thread_data()->interrupt_enabled=false; + } + } + } + + namespace detail + { + void add_thread_exit_function(thread_exit_function_base* func) + { + detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data()); + thread_exit_callback_node* const new_node= + new thread_exit_callback_node(func,current_thread_data->thread_exit_callbacks); + current_thread_data->thread_exit_callbacks=new_node; + } + + tss_data_node* find_tss_data(void const* key) + { + detail::thread_data_base* const current_thread_data(get_current_thread_data()); + if(current_thread_data) + { + std::map::iterator current_node= + current_thread_data->tss_data.find(key); + if(current_node!=current_thread_data->tss_data.end()) + { + return ¤t_node->second; + } + } + return NULL; + } + + void* get_tss_data(void const* key) + { + if(tss_data_node* const current_node=find_tss_data(key)) + { + return current_node->value; + } + return NULL; + } + + void add_new_tss_node(void const* key, + boost::shared_ptr func, + void* tss_data) + { + detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data()); + current_thread_data->tss_data.insert(std::make_pair(key,tss_data_node(func,tss_data))); + } + + void erase_tss_node(void const* key) + { + detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data()); + current_thread_data->tss_data.erase(key); + } + + void set_tss_data(void const* key, + boost::shared_ptr func, + void* tss_data,bool cleanup_existing) + { + if(tss_data_node* const current_node=find_tss_data(key)) + { + if(cleanup_existing && current_node->func && (current_node->value!=0)) + { + (*current_node->func)(current_node->value); + } + if(func || (tss_data!=0)) + { + current_node->func=func; + current_node->value=tss_data; + } + else + { + erase_tss_node(key); + } + } + else + { + add_new_tss_node(key,func,tss_data); + } + } + } + + +} diff --git a/Boost/lib/pthread/timeconv.inl b/Boost/lib/pthread/timeconv.inl new file mode 100644 index 000000000..b75a1353b --- /dev/null +++ b/Boost/lib/pthread/timeconv.inl @@ -0,0 +1,133 @@ +// Copyright (C) 2001-2003 +// William E. Kempf +// Copyright (C) 2009 Anthony Williams +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// boostinspect:nounnamed + +#include + +namespace { +const int MILLISECONDS_PER_SECOND = 1000; +const int NANOSECONDS_PER_SECOND = 1000000000; +const int NANOSECONDS_PER_MILLISECOND = 1000000; + +const int MICROSECONDS_PER_SECOND = 1000000; +const int NANOSECONDS_PER_MICROSECOND = 1000; + +inline void to_time(int milliseconds, boost::xtime& xt) +{ + int res = 0; + res = boost::xtime_get(&xt, boost::TIME_UTC); + BOOST_ASSERT(res == boost::TIME_UTC); + + xt.sec += (milliseconds / MILLISECONDS_PER_SECOND); + xt.nsec += ((milliseconds % MILLISECONDS_PER_SECOND) * + NANOSECONDS_PER_MILLISECOND); + + if (xt.nsec >= NANOSECONDS_PER_SECOND) + { + ++xt.sec; + xt.nsec -= NANOSECONDS_PER_SECOND; + } +} + +#if defined(BOOST_HAS_PTHREADS) +inline void to_timespec(const boost::xtime& xt, timespec& ts) +{ + ts.tv_sec = static_cast(xt.sec); + ts.tv_nsec = static_cast(xt.nsec); + if(ts.tv_nsec >= NANOSECONDS_PER_SECOND) + { + ts.tv_sec += ts.tv_nsec / NANOSECONDS_PER_SECOND; + ts.tv_nsec %= NANOSECONDS_PER_SECOND; + } +} + +inline void to_time(int milliseconds, timespec& ts) +{ + boost::xtime xt; + to_time(milliseconds, xt); + to_timespec(xt, ts); +} + +inline void to_timespec_duration(const boost::xtime& xt, timespec& ts) +{ + boost::xtime cur; + int res = 0; + res = boost::xtime_get(&cur, boost::TIME_UTC); + BOOST_ASSERT(res == boost::TIME_UTC); + + if (boost::xtime_cmp(xt, cur) <= 0) + { + ts.tv_sec = 0; + ts.tv_nsec = 0; + } + else + { + ts.tv_sec = xt.sec - cur.sec; + ts.tv_nsec = xt.nsec - cur.nsec; + + if( ts.tv_nsec < 0 ) + { + ts.tv_sec -= 1; + ts.tv_nsec += NANOSECONDS_PER_SECOND; + } + if(ts.tv_nsec >= NANOSECONDS_PER_SECOND) + { + ts.tv_sec += ts.tv_nsec / NANOSECONDS_PER_SECOND; + ts.tv_nsec %= NANOSECONDS_PER_SECOND; + } + } +} +#endif + +inline void to_duration(boost::xtime xt, int& milliseconds) +{ + boost::xtime cur; + int res = 0; + res = boost::xtime_get(&cur, boost::TIME_UTC); + BOOST_ASSERT(res == boost::TIME_UTC); + + if (boost::xtime_cmp(xt, cur) <= 0) + milliseconds = 0; + else + { + if (cur.nsec > xt.nsec) + { + xt.nsec += NANOSECONDS_PER_SECOND; + --xt.sec; + } + milliseconds = (int)((xt.sec - cur.sec) * MILLISECONDS_PER_SECOND) + + (((xt.nsec - cur.nsec) + (NANOSECONDS_PER_MILLISECOND/2)) / + NANOSECONDS_PER_MILLISECOND); + } +} + +inline void to_microduration(boost::xtime xt, int& microseconds) +{ + boost::xtime cur; + int res = 0; + res = boost::xtime_get(&cur, boost::TIME_UTC); + BOOST_ASSERT(res == boost::TIME_UTC); + + if (boost::xtime_cmp(xt, cur) <= 0) + microseconds = 0; + else + { + if (cur.nsec > xt.nsec) + { + xt.nsec += NANOSECONDS_PER_SECOND; + --xt.sec; + } + microseconds = (int)((xt.sec - cur.sec) * MICROSECONDS_PER_SECOND) + + (((xt.nsec - cur.nsec) + (NANOSECONDS_PER_MICROSECOND/2)) / + NANOSECONDS_PER_MICROSECOND); + } +} +} + +// Change Log: +// 1 Jun 01 Initial creation. diff --git a/JGE/include/DebugRoutines.h b/JGE/include/DebugRoutines.h index 6546daea8..411247765 100644 --- a/JGE/include/DebugRoutines.h +++ b/JGE/include/DebugRoutines.h @@ -25,27 +25,34 @@ std::string ToHex(T* pointer) #define OutputDebugString(val) (std::cerr << val); #endif -#if defined (WIN32) || defined (LINUX) #ifdef _DEBUG +#if defined (WIN32) || defined (LINUX) -#ifndef QT_CONFIG +#ifdef QT_CONFIG #define DebugTrace(inString) \ { \ - std::ostringstream stream; \ - stream << inString << std::endl; \ - OutputDebugString(stream.str().c_str()); \ + std::ostringstream stream; \ + stream << inString << std::endl; \ + qDebug(stream.str().c_str()); \ +} +#elif defined (ANDROID) +#include +#define DebugTrace(inString) \ +{ \ + std::ostringstream stream; \ + stream << inString; \ + __android_log_write(ANDROID_LOG_DEBUG, "Wagic", stream.str().c_str());\ } #else #define DebugTrace(inString) \ { \ std::ostringstream stream; \ stream << inString << std::endl; \ - qDebug(stream.str().c_str()); \ + OutputDebugString(stream.str().c_str()); \ } -#endif //QT_CONFIG - -#endif //#ifdef _DEBUG +#endif // QT_CONFIG #endif // Win32, Linux +#endif //#ifdef _DEBUG #if defined (DEBUG) #ifndef DebugTrace diff --git a/JGE/include/JGE.h b/JGE/include/JGE.h index f3ac1b54a..d858fb2c3 100644 --- a/JGE/include/JGE.h +++ b/JGE/include/JGE.h @@ -29,6 +29,11 @@ typedef u32 LocalKeySym; #define LOCAL_KEY_NONE Qt::Key_unknown +#elif defined(SDL_CONFIG) +#include +typedef SDLKey LocalKeySym; +#define LOCAL_KEY_NONE SDLK_UNKNOWN + #elif defined(WIN32) #include typedef WPARAM LocalKeySym; @@ -50,7 +55,6 @@ typedef u32 LocalKeySym; #endif - bool JGEGetButtonState(const JButton button); bool JGEGetButtonClick(const JButton button); void JGECreateDefaultBindings(); diff --git a/JGE/include/JTypes.h b/JGE/include/JTypes.h index d657295ff..3baaa982c 100644 --- a/JGE/include/JTypes.h +++ b/JGE/include/JTypes.h @@ -101,22 +101,13 @@ enum { #import #import #import -# import + # import +#elif defined (ANDROID) + #include + #include #elif defined (WIN32) || defined (LINUX) #include #include - -//Android GL1 support TODO -/* -#elif defined (ANDROID) - #include - #include -*/ -//Android GL2 support -#elif defined (ANDROID) - #include - #include - #endif #else # include diff --git a/JGE/src/JFileSystem.cpp b/JGE/src/JFileSystem.cpp index d76a100c3..09b37b282 100644 --- a/JGE/src/JFileSystem.cpp +++ b/JGE/src/JFileSystem.cpp @@ -269,6 +269,8 @@ void JFileSystem::SetResourceRoot(const string& resourceRoot) NSString *fullpath = [[[NSBundle mainBundle] resourcePath] stringByAppendingPathComponent:pathUTF8]; mResourceRoot = [fullpath cStringUsingEncoding:1]; mResourceRoot += "/"; +#elif defined (ANDROID) + mResourceRoot = "/sdcard/Wagic/Res/"; #else mResourceRoot = resourceRoot; #endif diff --git a/JGE/src/SDLmain.cpp b/JGE/src/SDLmain.cpp new file mode 100644 index 000000000..acfe7509c --- /dev/null +++ b/JGE/src/SDLmain.cpp @@ -0,0 +1,448 @@ +#include +#ifndef ANDROID +#include +#else +#include +#endif +#include "../include/JGE.h" +#include "../include/JTypes.h" +#include "../include/JApp.h" +#include "../include/JFileSystem.h" +#include "../include/JRenderer.h" +#include "../include/JGameLauncher.h" +#include "DebugRoutines.h" +#include +#include + +#undef GL_VERSION_2_0 + +#define ACTUAL_SCREEN_WIDTH (SCREEN_WIDTH) +#define ACTUAL_SCREEN_HEIGHT (SCREEN_HEIGHT) +#define ACTUAL_RATIO ((GLfloat)ACTUAL_SCREEN_WIDTH / (GLfloat)ACTUAL_SCREEN_HEIGHT) + +#define WAGIC_UPDATE_EVENT (SDL_USEREVENT + 1) + +class SdlApp { + private: + bool Running; + SDL_Surface* Surf_Display; + SDL_Rect viewPort; + + public: + SdlApp() { + Surf_Display = NULL; + + Running = true; + }; + + int OnExecute() { + if(OnInit() == false) { + return -1; + } + + SDL_Event Event; + + while(Running) { + while(SDL_PollEvent(&Event)) { + OnEvent(&Event); + } + + OnLoop(); +// OnRender(); + } + + OnCleanup(); + + return 0; + }; + + public: + bool OnInit(); + + void OnResize(int width, int height) { + if ((GLfloat)width / (GLfloat)height <= ACTUAL_RATIO) + { + viewPort.x = 0; + viewPort.y = -((width/ACTUAL_RATIO)-height)/2; + viewPort.w = width; + viewPort.h = width / ACTUAL_RATIO; + } + else + { + viewPort.x = -(height*ACTUAL_RATIO-width)/2; + viewPort.y = 0; + viewPort.w = height * ACTUAL_RATIO; + viewPort.h = height; + } + + glViewport(viewPort.x, viewPort.y, viewPort.w, viewPort.h); + + JRenderer::GetInstance()->SetActualWidth(viewPort.w); + JRenderer::GetInstance()->SetActualHeight(viewPort.h); + glScissor(0, 0, width, height); + + #if (!defined GL_ES_VERSION_2_0) && (!defined GL_VERSION_2_0) + + glMatrixMode (GL_PROJECTION); // Select The Projection Matrix + glLoadIdentity (); // Reset The Projection Matrix + + //gluOrtho2D(0.0f, (float) (viewPort.w)-1.0f, 0.0f, (float) (viewPort.h)-1.0f); + +#if (defined GL_VERSION_ES_CM_1_1) + glOrthof(0.0f, (float) (viewPort.w)-1.0f, 0.0f, (float) (viewPort.h)-1.0f, -1.0f, 1.0f); +#else + gluOrtho2D(0.0f, (float) (viewPort.w)-1.0f, 0.0f, (float) (viewPort.h)-1.0f); +#endif + glMatrixMode (GL_MODELVIEW); // Select The Modelview Matrix + glLoadIdentity (); // Reset The Modelview Matrix + + glDisable (GL_DEPTH_TEST); + + #endif + }; + void OnKeyPressed(const SDL_KeyboardEvent& event); + void OnMouseClicked(const SDL_MouseButtonEvent& event); + void OnMouseMoved(const SDL_MouseMotionEvent& event); + void OnEvent(SDL_Event* Event) { + switch(Event->type){ + case SDL_QUIT: + Running = false; + break; + case SDL_VIDEORESIZE: + OnResize(Event->resize.w, Event->resize.h); + break; + case SDL_KEYDOWN: + case SDL_KEYUP: + OnKeyPressed(Event->key); + break; + case SDL_MOUSEMOTION: + OnMouseMoved(Event->motion); + break; + case SDL_MOUSEBUTTONDOWN: + case SDL_MOUSEBUTTONUP: + OnMouseClicked(Event->button); + break; + case WAGIC_UPDATE_EVENT: + OnUpdate(); + break; + } + } + void OnUpdate(); + void OnRender(); + void OnLoop() { + }; + + void OnCleanup() { + SDL_FreeSurface(Surf_Display); + SDL_Quit(); + } +}; + +uint64_t lastTickCount; +JGE* g_engine = NULL; +JApp* g_app = NULL; +JGameLauncher* g_launcher = NULL; +SdlApp *g_SdlApp = NULL; + + + +static const struct { LocalKeySym keysym; JButton keycode; } gDefaultBindings[] = +{ + { SDLK_RETURN, JGE_BTN_MENU }, + { SDLK_KP_ENTER, JGE_BTN_MENU }, + { SDLK_ESCAPE, JGE_BTN_MENU }, + { SDLK_BACKSPACE, JGE_BTN_CTRL }, + { SDLK_UP, JGE_BTN_UP }, + { SDLK_DOWN, JGE_BTN_DOWN }, + { SDLK_LEFT, JGE_BTN_LEFT }, + { SDLK_RIGHT, JGE_BTN_RIGHT }, + { SDLK_SPACE, JGE_BTN_OK }, + { SDLK_TAB, JGE_BTN_CANCEL }, + { SDLK_j, JGE_BTN_PRI }, + { SDLK_k, JGE_BTN_SEC }, + { SDLK_q, JGE_BTN_PREV }, + { SDLK_a, JGE_BTN_NEXT }, +// fullscreen management seems somehow broken in JGE, it works fine with Qt directly +// { Qt::Key_F, JGE_BTN_FULLSCREEN }, +}; + +void JGECreateDefaultBindings() +{ + for (signed int i = sizeof(gDefaultBindings)/sizeof(gDefaultBindings[0]) - 1; i >= 0; --i) + g_engine->BindKey(gDefaultBindings[i].keysym, gDefaultBindings[i].keycode); +} + +int JGEGetTime() +{ + return (int)SDL_GetTicks(); +} + +bool JGEToggleFullscreen() +{ + return true; +} + +bool InitGame(void) +{ + g_engine = JGE::GetInstance(); + g_app = g_launcher->GetGameApp(); + g_app->Create(); + g_engine->SetApp(g_app); + + JRenderer::GetInstance()->Enable2D(); + lastTickCount = JGEGetTime(); + + return true; +} + +void DestroyGame(void) +{ + g_engine->SetApp(NULL); + if (g_app) + { + g_app->Destroy(); + delete g_app; + g_app = NULL; + } + + JGE::Destroy(); + + g_engine = NULL; +} + +Uint32 OnTimer( Uint32 interval ) +{ + SDL_Event event; + event.user.type = WAGIC_UPDATE_EVENT; + SDL_PushEvent(&event); + return 30; +} + +void SdlApp::OnUpdate() { + static int tickCount; + Uint32 dt; + tickCount = JGEGetTime(); + dt = (tickCount - lastTickCount); + lastTickCount = tickCount; + + if(g_engine->IsDone()) { + SDL_Event event; + event.user.type = SDL_QUIT; + SDL_PushEvent(&event); + } + + try { + g_engine->SetDelta((float)dt / 1000.0f); + g_engine->Update((float)dt / 1000.0f); + } catch(out_of_range& oor) { + cerr << oor.what(); + } + + OnRender(); +} + +void SdlApp::OnKeyPressed(const SDL_KeyboardEvent& event) +{ + if(event.type == SDL_KEYDOWN) { + g_engine->HoldKey_NoRepeat((LocalKeySym)event.keysym.sym); + } else if(event.type == SDL_KEYUP) { + g_engine->ReleaseKey((LocalKeySym)event.keysym.sym); + } +} + +void SdlApp::OnMouseMoved(const SDL_MouseMotionEvent& event) +{ + int actualWidth = (int) JRenderer::GetInstance()->GetActualWidth(); + int actualHeight = (int) JRenderer::GetInstance()->GetActualHeight(); + + if (event.y >= viewPort.y && + event.y <= viewPort.y + viewPort.h && + event.x >= viewPort.x && + event.x <= viewPort.x + viewPort.w) { + g_engine->LeftClicked( + ((event.x-viewPort.x)*SCREEN_WIDTH)/actualWidth, + ((event.y-viewPort.y)*SCREEN_HEIGHT)/actualHeight); + } +} + +void SdlApp::OnMouseClicked(const SDL_MouseButtonEvent& event) +{ + if(event.type == SDL_MOUSEBUTTONDOWN) + { + if(event.button == SDL_BUTTON_LEFT) /* Left button */ + { + // this is intended to convert window coordinate into game coordinate. + // this is correct only if the game and window have the same aspect ratio, otherwise, it's just wrong + int actualWidth = (int) JRenderer::GetInstance()->GetActualWidth(); + int actualHeight = (int) JRenderer::GetInstance()->GetActualHeight(); + + if (event.y >= viewPort.y && + event.y <= viewPort.y + viewPort.h && + event.x >= viewPort.x && + event.x <= viewPort.x + viewPort.w) { + g_engine->LeftClicked( + ((event.x-viewPort.x)*SCREEN_WIDTH)/actualWidth, + ((event.y-viewPort.y)*SCREEN_HEIGHT)/actualHeight); + g_engine->HoldKey_NoRepeat(JGE_BTN_OK); + } else if(event.y < viewPort.y) { + g_engine->HoldKey_NoRepeat(JGE_BTN_MENU); + } else if(event.y > viewPort.y + viewPort.h) { + g_engine->HoldKey_NoRepeat(JGE_BTN_NEXT); + } + } + else if(event.button == SDL_BUTTON_RIGHT) /* Right button */ + { /* next phase please */ + g_engine->HoldKey_NoRepeat(JGE_BTN_PREV); + } + else if(event.button == SDL_BUTTON_MIDDLE) /* Middle button */ + { /* interrupt please */ + g_engine->HoldKey_NoRepeat(JGE_BTN_SEC); + } + } else if (event.type == SDL_MOUSEBUTTONUP) + { + if(event.button == SDL_BUTTON_LEFT) + { + if (event.y >= viewPort.y && + event.y <= viewPort.y + viewPort.h && + event.x >= viewPort.x && + event.x <= viewPort.x + viewPort.w) { + g_engine->ReleaseKey(JGE_BTN_OK); + } else if(event.y < viewPort.y) { + g_engine->ReleaseKey(JGE_BTN_MENU); + } else if(event.y > viewPort.y + viewPort.h) { + g_engine->ReleaseKey(JGE_BTN_NEXT); + } + } + else if(event.button == SDL_BUTTON_RIGHT) + { /* next phase please */ + g_engine->ReleaseKey(JGE_BTN_PREV); + } + else if(event.button == SDL_BUTTON_MIDDLE) + { /* interrupt please */ + g_engine->ReleaseKey(JGE_BTN_SEC); + } + } +} + +bool SdlApp::OnInit() { + if(SDL_Init(SDL_INIT_EVERYTHING) < 0) { + return false; + } + + SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8); + SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8); + SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8); + SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8); + + SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16); + SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32); + + SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, 8); + SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, 8); + SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, 8); + SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, 8); + + SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); + + SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 2); + + if((Surf_Display = SDL_SetVideoMode(ACTUAL_SCREEN_WIDTH, ACTUAL_SCREEN_HEIGHT, 32, /*SDL_HWSURFACE | SDL_GL_DOUBLEBUFFER |*/ SDL_OPENGL | SDL_RESIZABLE)) == NULL) { + return false; + } + + SDL_WM_SetCaption(g_launcher->GetName(), ""); + + glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Black Background (yes that's the way fuckers) +#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) +#if (defined GL_ES_VERSION_2_0) + glClearDepthf(1.0f); // Depth Buffer Setup +#else + glClearDepth(1.0f); // Depth Buffer Setup +#endif// (defined GL_ES_VERSION_2_0) + + glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing (Less Or Equal) + glEnable(GL_DEPTH_TEST); // Enable Depth Testing + +#else +#if (defined GL_VERSION_ES_CM_1_1) + glClearDepthf(1.0f); // Depth Buffer Setup +#else + glClearDepth(1.0f); // Depth Buffer Setup +#endif + glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing (Less Or Equal) + glEnable(GL_DEPTH_TEST); // Enable Depth Testing + glShadeModel(GL_SMOOTH); // Select Smooth Shading + glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Set Perspective Calculations To Most Accurate + + glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); // Set Line Antialiasing + glEnable(GL_LINE_SMOOTH); // Enable it! + glEnable(GL_TEXTURE_2D); + +#endif + + glEnable(GL_CULL_FACE); // do not calculate inside of poly's + glFrontFace(GL_CCW); // counter clock-wise polygons are out + + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + + glEnable(GL_SCISSOR_TEST); // Enable Clipping + + + OnResize(ACTUAL_SCREEN_WIDTH, ACTUAL_SCREEN_HEIGHT); + + /* opengl needs to be fully initialized before starting the game */ + if (!InitGame()) + { + cerr << "Could not init the game\n"; + return false; + } + + JGECreateDefaultBindings(); + + SDL_SetTimer(5, OnTimer); + + return true; +}; + +void SdlApp::OnRender() { + + if(g_engine) + g_engine->Render(); + + SDL_GL_SwapBuffers(); +}; + + +#ifdef ANDROID +int SDL_main(int argc, char * argv[]) +#else +int main(int argc, char* argv[]) +#endif //ANDROID +{ + DebugTrace("I R in da native"); + + g_launcher = new JGameLauncher(); + + u32 flags = g_launcher->GetInitFlags(); + + if ((flags&JINIT_FLAG_ENABLE3D)!=0) + { + JRenderer::Set3DFlag(true); + } + + g_SdlApp = new SdlApp(); + + int result = g_SdlApp->OnExecute(); + + if (g_launcher) + delete g_launcher; + + if(g_SdlApp) + delete g_SdlApp; + + // Shutdown + DestroyGame(); + + return result; +} diff --git a/JGE/src/pc/JGfx.cpp b/JGE/src/pc/JGfx.cpp index 4f428faea..c5d116aaf 100644 --- a/JGE/src/pc/JGfx.cpp +++ b/JGE/src/pc/JGfx.cpp @@ -9,7 +9,7 @@ //------------------------------------------------------------------------------------- #define GL_GLEXT_PROTOTYPES -#if (!defined IOS) +#if (!defined IOS) && (!defined QT_CONFIG) #ifdef WIN32 #pragma warning(disable : 4786) #pragma comment( lib, "giflib.lib" ) @@ -42,12 +42,18 @@ extern "C" { #endif #ifdef _DEBUG -#define checkGlError() \ +void checkGlError() +{ + GLenum glError = glGetError(); + if(glError != 0) + printf("%s : %u : GLerror is %u\n", __FUNCTION__, __LINE__, glError); +} +/*#define checkGlError() \ { \ GLenum glError = glGetError(); \ if(glError != 0) \ printf("%s : %u : GLerror is %u\n", __FUNCTION__, __LINE__, glError); \ -} +}/*/ #else #define checkGlError() (void(0)) #endif @@ -955,32 +961,44 @@ void JRenderer::RenderQuad(JQuad* quad, float xo, float yo, float angle, float x // Use the program object glUseProgram ( prog2 ); + checkGlError(); // Load the vertex position glVertexAttribPointer ( prog2_positionLoc, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), vVertices ); + checkGlError(); // Load the texture coordinate glVertexAttribPointer ( prog2_texCoordLoc, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), &vVertices[3] ); + checkGlError(); // Load the colors glVertexAttribPointer ( prog2_colorLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 4 * sizeof(GLubyte), colorCoords ); + checkGlError(); glEnableVertexAttribArray ( prog2_positionLoc ); + checkGlError(); glEnableVertexAttribArray ( prog2_texCoordLoc ); + checkGlError(); glEnableVertexAttribArray ( prog2_colorLoc ); + checkGlError(); // Load the MVP matrix glUniformMatrix4fv( prog2_mvpLoc, 1, GL_FALSE, (GLfloat*) &mvpMatrix.m[0][0] ); + checkGlError(); // Bind the texture glActiveTexture ( GL_TEXTURE0 ); + checkGlError(); glBindTexture ( GL_TEXTURE_2D, mCurrentTex ); + checkGlError(); // Set the sampler texture unit to 0 glUniform1i ( prog2_samplerLoc, 0 ); + checkGlError(); glDrawArrays(GL_TRIANGLE_STRIP,0,4); + checkGlError(); #else glPushMatrix(); @@ -988,7 +1006,7 @@ void JRenderer::RenderQuad(JQuad* quad, float xo, float yo, float angle, float x glRotatef(-angle*RAD2DEG, 0.0f, 0.0f, 1.0f); glScalef(xScale, yScale, 1.0f); -#if (defined GL_ES_VERSION_1_1) || (defined GL_VERSION_1_1) +#if (defined GL_VERSION_ES_CM_1_1) glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_COLOR_ARRAY); @@ -1121,6 +1139,41 @@ void JRenderer::RenderQuad(JQuad* quad, VertexColor* pt) //glDrawElements ( GL_TRIANGLE_STRIP, 6, GL_UNSIGNED_SHORT, indices ); glDrawArrays(GL_TRIANGLE_STRIP,0,4); + +#elif (defined GL_VERSION_ES_CM_1_1) + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + glEnableClientState(GL_COLOR_ARRAY); + + GLfloat vertCoords[] = { + pt[0].x, pt[0].y, + pt[1].x, pt[1].y, + pt[3].x, pt[3].y, + pt[2].x, pt[2].y, + }; + + GLfloat texCoords[] = { + uv[0].x, uv[0].y, + uv[1].x, uv[1].y, + uv[3].x, uv[3].y, + uv[2].x, uv[2].y, + }; + + GLubyte colorCoords[] = { + quad->mColor[0].r, quad->mColor[0].g, quad->mColor[0].b, quad->mColor[0].a, + quad->mColor[1].r, quad->mColor[1].g, quad->mColor[1].b, quad->mColor[1].a, + quad->mColor[3].r, quad->mColor[3].g, quad->mColor[3].b, quad->mColor[3].a, + quad->mColor[2].r, quad->mColor[2].g, quad->mColor[2].b, quad->mColor[2].a, + }; + + glVertexPointer(2,GL_FLOAT,0,vertCoords); + glTexCoordPointer(2,GL_FLOAT,0, texCoords); + glColorPointer(4, GL_UNSIGNED_BYTE, 0, colorCoords ); + glDrawArrays(GL_TRIANGLE_STRIP,0,4); + + glDisableClientState(GL_COLOR_ARRAY); + glDisableClientState(GL_TEXTURE_COORD_ARRAY); + glDisableClientState(GL_VERTEX_ARRAY); #else glRasterPos2f(pt[0].x, pt[0].y); @@ -1195,7 +1248,33 @@ void JRenderer::FillRect(float x, float y, float width, float height, PIXEL_TYPE glUniformMatrix4fv( prog1_mvpLoc, 1, GL_FALSE, (GLfloat*) &theMvpMatrix.m[0][0] ); glDrawArrays(GL_TRIANGLE_STRIP,0,4); + +#elif (defined GL_VERSION_ES_CM_1_1) + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_COLOR_ARRAY); + + GLfloat vVertices[] = { + x, y+height, + x, y, + x+width, y+height, + x+width, y, + }; + + GLubyte colors[] = { + col.r, col.g, col.b, col.a, + col.r, col.g, col.b, col.a, + col.r, col.g, col.b, col.a, + col.r, col.g, col.b, col.a, + }; + + glVertexPointer(2,GL_FLOAT,0,vVertices); + glColorPointer(4, GL_UNSIGNED_BYTE, 0, colors ); + glDrawArrays(GL_TRIANGLE_STRIP,0,4); + + glDisableClientState(GL_COLOR_ARRAY); + glDisableClientState(GL_VERTEX_ARRAY); #else + glDisable(GL_TEXTURE_2D); glColor4ub(col.r, col.g, col.b, col.a); @@ -1264,6 +1343,31 @@ void JRenderer::DrawRect(float x, float y, float width, float height, PIXEL_TYPE glUniformMatrix4fv( prog1_mvpLoc, 1, GL_FALSE, (GLfloat*) &theMvpMatrix.m[0][0] ); glDrawArrays(GL_LINE_LOOP,0,4); + +#elif (defined GL_VERSION_ES_CM_1_1) + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_COLOR_ARRAY); + + GLfloat vertCoords[] = { + x, y, + x, y+height, + x+width, y+height, + x+width, y, + }; + + GLubyte colorCoords[] = { + col.r, col.g, col.b, col.a, + col.r, col.g, col.b, col.a, + col.r, col.g, col.b, col.a, + col.r, col.g, col.b, col.a, + }; + + glVertexPointer(2,GL_FLOAT,0,vertCoords); + glColorPointer(4, GL_UNSIGNED_BYTE, 0, colorCoords ); + glDrawArrays(GL_LINE_LOOP,0,4); + + glDisableClientState(GL_COLOR_ARRAY); + glDisableClientState(GL_VERTEX_ARRAY); #else glDisable(GL_TEXTURE_2D); glColor4ub(col.r, col.g, col.b, col.a); @@ -1301,7 +1405,6 @@ void JRenderer::FillRect(float x, float y, float width, float height, PIXEL_TYPE FillRect(x, y, width, height, col); } - void JRenderer::FillRect(float x, float y, float width, float height, JColor* colors) { checkGlError(); @@ -1339,6 +1442,30 @@ void JRenderer::FillRect(float x, float y, float width, float height, JColor* co glUniformMatrix4fv( prog1_mvpLoc, 1, GL_FALSE, (GLfloat*) &theMvpMatrix.m[0][0] ); glDrawArrays(GL_TRIANGLE_STRIP,0,4); +#elif (defined GL_VERSION_ES_CM_1_1) + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_COLOR_ARRAY); + + GLfloat vVertices[] = { + x, y+height, + x, y, + x+width, y+height, + x+width, y, + }; + + GLubyte cols[] = { + colors[0].r, colors[0].g, colors[0].b, colors[0].a, + colors[2].r, colors[2].g, colors[2].b, colors[2].a, + colors[1].r, colors[1].g, colors[1].b, colors[1].a, + colors[3].r, colors[3].g, colors[3].b, colors[3].a, + }; + + glVertexPointer(2,GL_FLOAT,0,vVertices); + glColorPointer(4, GL_UNSIGNED_BYTE, 0, cols ); + glDrawArrays(GL_TRIANGLE_STRIP,0,4); + + glDisableClientState(GL_COLOR_ARRAY); + glDisableClientState(GL_VERTEX_ARRAY); #else glDisable(GL_TEXTURE_2D); glBegin(GL_QUADS); @@ -1404,6 +1531,28 @@ void JRenderer::DrawLine(float x1, float y1, float x2, float y2, PIXEL_TYPE colo glUniformMatrix4fv( prog1_mvpLoc, 1, GL_FALSE, (GLfloat*) &theMvpMatrix.m[0][0] ); glDrawArrays(GL_LINES,0,2); + +#elif (defined GL_VERSION_ES_CM_1_1) + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_COLOR_ARRAY); + + GLfloat vVertices[] = { + x1, SCREEN_HEIGHT_F-y1, 0.0f, + x2, SCREEN_HEIGHT_F-y2, 0.0f, + }; + + GLubyte cols[] = { + col.r, col.g, col.b, col.a, + col.r, col.g, col.b, col.a, + }; + + glVertexPointer(2,GL_FLOAT,0,vVertices); + glColorPointer(4, GL_UNSIGNED_BYTE, 0, cols ); + glDrawArrays(GL_LINES,0,2); + + glDisableClientState(GL_COLOR_ARRAY); + glDisableClientState(GL_VERTEX_ARRAY); + #else glDisable(GL_TEXTURE_2D); glColor4ub(col.r, col.g, col.b, col.a); @@ -1424,7 +1573,7 @@ void JRenderer::Plot(float x, float y, PIXEL_TYPE color) glDisable(GL_TEXTURE_2D); JColor col; col.color = color; -#if (!defined GL_ES_VERSION_2_0) && (!defined GL_VERSION_2_0) +#if (!defined GL_ES_VERSION_2_0) && (!defined GL_VERSION_2_0) && (!defined GL_VERSION_ES_CM_1_1) glColor4ub(col.r, col.g, col.b, col.a); glBegin(GL_POINTS); glVertex2f(x, SCREEN_HEIGHT_F-y); @@ -1444,7 +1593,7 @@ void JRenderer::PlotArray(float *x, float *y, int count, PIXEL_TYPE color) glDisable(GL_TEXTURE_2D); JColor col; col.color = color; -#if (!defined GL_ES_VERSION_2_0) && (!defined GL_VERSION_2_0) +#if (!defined GL_ES_VERSION_2_0) && (!defined GL_VERSION_2_0) && (!defined GL_VERSION_ES_CM_1_1) glColor4ub(col.r, col.g, col.b, col.a); glBegin(GL_POINTS); for (int i=0;iOpenFile(filename)) return JGE_ERR_CANT_OPEN_FILE; + if (!fileSystem->OpenFile(filename)) + return JGE_ERR_CANT_OPEN_FILE; png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); if (png_ptr == NULL) @@ -1781,8 +1933,8 @@ int JRenderer::LoadPNG(TextureInfo &textureInfo, const char *filename, int mode int g = (color32 >> 8) & 0xff; int b = (color32 >> 16) & 0xff; - color32 = r | (g << 8) | (b << 16) | (a << 24); - *(p32+x) = color32; + color32 = r | (g << 8) | (b << 16) | (a << 24); + *(p32+x) = color32; } p32 += tw; @@ -1821,7 +1973,7 @@ int JRenderer::LoadPNG(TextureInfo &textureInfo, const char *filename, int mode // } - +#if (!defined IOS) && (!defined QT_CONFIG) && (!defined SDL_CONFIG) ////////////////////////////////////////////////////////////////////////// /// GIF Support int JRenderer::image_readgif(void * handle, TextureInfo &textureInfo, DWORD * bgcolor, InputFunc readFunc, int mode __attribute__((unused)), int TextureFormat __attribute__((unused))) @@ -1983,6 +2135,7 @@ void JRenderer::LoadGIF(TextureInfo &textureInfo, const char *filename, int mode fileSys->CloseFile(); return ;//*/ } +#endif //(!defined IOS) && (!defined QT_CONFIG) && (!defined SDL_CONFIG) #elif (defined IOS) @@ -2316,7 +2469,11 @@ void JRenderer::Enable2D() glMatrixMode (GL_PROJECTION); // Select The Projection Matrix glLoadIdentity (); // Reset The Projection Matrix - gluOrtho2D(0.0f, SCREEN_WIDTH_F, 0.0f, SCREEN_HEIGHT_F-1.0f); +#if (defined GL_VERSION_ES_CM_1_1) + glOrthof(0.0f, SCREEN_WIDTH_F, 0.0f, SCREEN_HEIGHT_F-1.0f, -1.0f, 1.0f); +#else + gluOrtho2D(0.0f, SCREEN_WIDTH_F, 0.0f, SCREEN_HEIGHT_F-1.0f); +#endif glMatrixMode (GL_MODELVIEW); // Select The Modelview Matrix glLoadIdentity (); // Reset The Modelview Matrix @@ -2439,6 +2596,26 @@ void JRenderer::RenderTriangles(JTexture* texture, Vertex3D *vertices, int start glDrawArrays(GL_TRIANGLES,0,count*3); delete[] colorCoords; + +#elif (defined GL_VERSION_ES_CM_1_1) + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + glEnableClientState(GL_COLOR_ARRAY); + + GLubyte* colorCoords = new GLubyte[count*3*4]; + memset(colorCoords, 255, count*3*4); + + glVertexPointer(3, GL_FLOAT, 5 * sizeof(GLfloat), &vertices[index].x); + glTexCoordPointer(2,GL_FLOAT,5 * sizeof(GLfloat), &vertices[index].u); + glColorPointer(4, GL_UNSIGNED_BYTE, 0, colorCoords ); + glDrawArrays(GL_TRIANGLES,0,count*3); + + glDisableClientState(GL_COLOR_ARRAY); + glDisableClientState(GL_TEXTURE_COORD_ARRAY); + glDisableClientState(GL_VERTEX_ARRAY); + + delete[] colorCoords; + #else glBegin(GL_TRIANGLES); for (int i = 0; i < count; i++) @@ -2478,9 +2655,9 @@ void JRenderer::FillPolygon(float* x, float* y, int count, PIXEL_TYPE color) checkGlError(); JColor col; col.color = color; + int i; #if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) - int i; GLubyte* colors = new GLubyte[count*4]; GLfloat* vVertices = new GLfloat[count*3]; @@ -2520,12 +2697,44 @@ void JRenderer::FillPolygon(float* x, float* y, int count, PIXEL_TYPE color) delete[] vVertices; delete[] colors; +#elif (defined GL_VERSION_ES_CM_1_1) + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_COLOR_ARRAY); + + GLubyte* colors = new GLubyte[count*4]; + GLfloat* vVertices = new GLfloat[count*3]; + + for(i = 0; i < count; i++) + { + colors[4*i+0]= col.r; + colors[4*i+1]= col.g; + colors[4*i+2]= col.b; + colors[4*i+3]= col.a; + } + + for(i=0; i < count;i++) + { + vVertices[3*i+0] = x[i]; + vVertices[3*i+1] = SCREEN_HEIGHT_F-y[i]; + vVertices[3*i+2] = 0.0f; + } + + glVertexPointer(3, GL_FLOAT, 0, vVertices); + glColorPointer(4, GL_UNSIGNED_BYTE, 0, colors ); + glDrawArrays(GL_TRIANGLE_FAN,0,count); + + glDisableClientState(GL_COLOR_ARRAY); + glDisableClientState(GL_VERTEX_ARRAY); + + delete[] vVertices; + delete[] colors; + #else glDisable(GL_TEXTURE_2D); glColor4ub(col.r, col.g, col.b, col.a); glBegin(GL_TRIANGLE_FAN); - for(int i=0; i= 360.0f) + angle -= 360.0f; + } + + glVertexPointer(3, GL_FLOAT, 0, vVertices); + glColorPointer(4, GL_UNSIGNED_BYTE, 0, colors ); + glDrawArrays(GL_LINE_LOOP,0,count); + + glDisableClientState(GL_COLOR_ARRAY); + glDisableClientState(GL_VERTEX_ARRAY); + + delete[] vVertices; + delete[] colors; + #else glDisable(GL_TEXTURE_2D); glColor4ub(col.r, col.g, col.b, col.a); glBegin(GL_LINE_LOOP); - for(int i=0; i= 360.0f) + angle -= 360.0f; + } + + vVertices[3*(1+count)+0] = x+size*COSF((int)firstAngle); + vVertices[3*(1+count)+1] = SCREEN_HEIGHT_F-y+size*SINF((int)firstAngle); + vVertices[3*(1+count)+2] = 0.0f; + + glVertexPointer(3, GL_FLOAT, 0, vVertices); + glColorPointer(4, GL_UNSIGNED_BYTE, 0, colors ); + glDrawArrays(GL_TRIANGLE_FAN,0,count+2); + + glDisableClientState(GL_COLOR_ARRAY); + glDisableClientState(GL_VERTEX_ARRAY); + + delete[] vVertices; + delete[] colors; + #else glDisable(GL_TEXTURE_2D); glColor4ub(col.r, col.g, col.b, col.a); @@ -2936,7 +3347,7 @@ void JRenderer::FillPolygon(float x, float y, float size, int count, float start glVertex2f(x, SCREEN_HEIGHT_F-y); - for(int i=0; i +#endif using std::string; using std::map; @@ -20,9 +22,12 @@ const KeyRep& translateKey(LocalKeySym key) } char* str = NULL; -#if !defined(QT_CONFIG) && !defined(IOS) && !defined(ANDROID) + +#if !defined(QT_CONFIG) && !defined(IOS) && !defined (SDL_CONFIG) str = XKeysymToString(key); -#endif // QT_CONFIG +#elif defined (SDL_CONFIG) + str = (char*)SDL_GetKeyName(key); +#endif if (!str) { str = NEW char[11]; diff --git a/projects/mtg/wagic-SDL.pro b/projects/mtg/wagic-SDL.pro new file mode 100644 index 000000000..5e0adebbe --- /dev/null +++ b/projects/mtg/wagic-SDL.pro @@ -0,0 +1,389 @@ +#------------------------------------------------- +# +# Project created by QtCreator 2010-06-30T19:48:30 +# +#------------------------------------------------- + +#QT += core gui opengl network +macx:QT += phonon +#CONFIG += warn_off precompile_header // causes some massives errors on mac. +VERSION = 0.14.1 +TARGET = wagic +TEMPLATE = app +unix|macx:QMAKE_CXXFLAGS += -Wno-unused-parameter +windows:DEFINES += WIN32 +windows:DEFINES += _CRT_SECURE_NO_WARNINGS +unix|macx:DEFINES += LINUX +CONFIG(debug, debug|release):DEFINES += _DEBUG +#DEFINES += QT_CONFIG +#DEFINES += NETWORK_SUPPORT +DEFINES += SDL_CONFIG +macx:DEFINES += USE_PHONON +maemo5: { +DEFINES += USE_PHONON +QT += phonon dbus +} +windows:INCLUDEPATH += ../../JGE/Dependencies/include +windows:INCLUDEPATH += extra +unix:INCLUDEPATH += /usr/include/GL +unix:INCLUDEPATH += /usr/local/include/SDL +macx:INCLUDEPATH += /opt/include +INCLUDEPATH += ../../JGE/include +INCLUDEPATH += ../../JGE/include/unzip +INCLUDEPATH += ../../Boost +INCLUDEPATH += include +OBJECTS_DIR = objs +MOC_DIR = objs +DESTDIR = bin + +macx|unix:LIBS += -lz -lboost_thread-mt +unix:LIBS += -ljpeg -lgif -lpng12 -L/usr/local/lib -lGL -lGLU -lSDL +windows:LIBS += -L../../JGE/Dependencies/lib -L../../Boost/lib -llibjpeg-static-mt-debug -lgiflib -llibpng -lfmodvc + +PRECOMPILED_HEADER = include/PrecompiledHeader.h + +# MGT +SOURCES += \ + src/ActionElement.cpp\ + src/ActionLayer.cpp\ + src/ActionStack.cpp\ + src/AIMomirPlayer.cpp\ + src/AIPlayer.cpp\ + src/AIStats.cpp\ + src/AllAbilities.cpp\ + src/CardDescriptor.cpp\ + src/CardDisplay.cpp\ + src/CardEffect.cpp\ + src/CardGui.cpp\ + src/CardPrimitive.cpp\ + src/CardSelector.cpp\ + src/CardSelectorSingleton.cpp\ + src/Closest.cpp\ + src/Counters.cpp\ + src/Credits.cpp\ + src/Damage.cpp\ + src/DamagerDamaged.cpp\ + src/DeckDataWrapper.cpp\ + src/DeckEditorMenu.cpp\ + src/DeckManager.cpp\ + src/DeckMenu.cpp\ + src/DeckMenuItem.cpp\ + src/DeckMetaData.cpp\ + src/DeckStats.cpp\ + src/DuelLayers.cpp\ + src/Effects.cpp\ + src/ExtraCost.cpp\ + src/GameApp.cpp\ + src/GameLauncher.cpp\ + src/GameObserver.cpp\ + src/GameOptions.cpp\ + src/GameStateAwards.cpp\ + src/GameState.cpp\ + src/GameStateDeckViewer.cpp\ + src/GameStateDuel.cpp\ + src/GameStateMenu.cpp\ + src/GameStateOptions.cpp\ + src/GameStateShop.cpp\ + src/GameStateStory.cpp\ + src/GameStateTransitions.cpp\ + src/GuiAvatars.cpp\ + src/GuiBackground.cpp\ + src/GuiCardsController.cpp\ + src/GuiCombat.cpp\ + src/GuiFrame.cpp\ + src/GuiHand.cpp\ + src/GuiLayers.cpp\ + src/GuiMana.cpp\ + src/GuiPhaseBar.cpp\ + src/GuiPlay.cpp\ + src/GuiStatic.cpp\ + src/ManaCost.cpp\ + src/ManaCostHybrid.cpp\ + src/MenuItem.cpp\ + src/MTGAbility.cpp\ + src/MTGCard.cpp\ + src/MTGCardInstance.cpp\ + src/MTGDeck.cpp\ + src/MTGDefinitions.cpp\ + src/MTGGamePhase.cpp\ + src/MTGGameZones.cpp\ + src/MTGPack.cpp\ + src/MTGRules.cpp\ + src/ObjectAnalytics.cpp\ + src/OptionItem.cpp\ + src/PhaseRing.cpp\ + src/Player.cpp\ + src/PlayerData.cpp\ + src/PlayGuiObject.cpp\ + src/PlayGuiObjectController.cpp\ + src/PlayRestrictions.cpp\ + src/Pos.cpp\ + src/PriceList.cpp\ + src/ReplacementEffects.cpp\ + src/Rules.cpp\ + src/SimpleMenu.cpp\ + src/SimpleMenuItem.cpp\ + src/SimplePad.cpp\ + src/SimplePopup.cpp\ + src/StoryFlow.cpp\ + src/Subtypes.cpp\ + src/StyleManager.cpp\ + src/TargetChooser.cpp\ + src/TargetsList.cpp\ + src/Tasks.cpp\ + src/TextScroller.cpp\ + src/ThisDescriptor.cpp\ + src/Token.cpp\ + src/Translate.cpp\ + src/TranslateKeys.cpp\ + src/Trash.cpp\ + src/utils.cpp\ + src/WCachedResource.cpp\ + src/WDataSrc.cpp\ + src/WEvent.cpp\ + src/WFilter.cpp\ + src/WFont.cpp\ + src/WGui.cpp\ + src/WResourceManager.cpp\ + src/NetworkPlayer.cpp + +CONFIG(debug, debug|release):SOURCES += src/TestSuiteAI.cpp + +HEADERS += \ + include/AllAbilities.h\ + include/DeckMenu.h\ + include/DeckMenuItem.h\ + include/ExtraCost.h\ + include/ManaCost.h\ + include/SimpleMenuItem.h\ + include/GameApp.h\ + include/ManaCostHybrid.h\ + include/SimplePad.h\ + include/ActionElement.h\ + include/GameObserver.h\ + include/MenuItem.h\ + include/StoryFlow.h\ + include/ActionLayer.h\ + include/GameOptions.h\ + include/MTGAbility.h\ + include/Subtypes.h\ + include/ActionStack.h\ + include/GameStateAwards.h\ + include/MTGCard.h\ + include/AIMomirPlayer.h\ + include/GameStateDeckViewer.h\ + include/MTGCardInstance.h\ + include/Targetable.h\ + include/AIPlayer.h\ + include/GameStateDuel.h\ + include/MTGDeck.h\ + include/TargetChooser.h\ + include/AIStats.h\ + include/GameState.h\ + include/MTGDefinitions.h\ + include/TargetsList.h\ + include/AllAbilities.h\ + include/GameStateMenu.h\ + include/MTGGamePhase.h\ + include/Tasks.h\ + include/CardDescriptor.h\ + include/GameStateOptions.h\ + include/MTGGameZones.h\ + include/TestSuiteAI.h\ + include/CardDisplay.h\ + include/GameStateShop.h\ + include/MTGPack.h\ + include/TextScroller.h\ + include/CardEffect.h\ + include/GameStateStory.h\ + include/MTGRules.h\ + include/ThisDescriptor.h\ + include/CardGui.h\ + include/GameStateTransitions.h\ + include/OptionItem.h\ + include/Token.h\ + include/CardPrimitive.h\ + include/GuiAvatars.h\ + include/OSD.h\ + include/Translate.h\ + include/CardSelector.h\ + include/CardSelectorSingleton.h\ + include/GuiBackground.h\ + include/PhaseRing.h\ + include/TranslateKeys.h\ + include/config.h\ + include/GuiCardsController.h\ + include/PlayerData.h\ + include/Trash.h\ + include/Counters.h\ + include/GuiCombat.h\ + include/Player.h\ + include/utils.h\ + include/Credits.h\ + include/GuiFrame.h\ + include/PlayGuiObjectController.h\ + include/WCachedResource.h\ + include/Damage.h\ + include/GuiHand.h\ + include/PlayGuiObject.h\ + include/WDataSrc.h\ + include/DamagerDamaged.h\ + include/GuiLayers.h\ + include/Pos.h\ + include/WEvent.h\ + include/DeckDataWrapper.h\ + include/GuiMana.h\ + include/PriceList.h\ + include/WFilter.h\ + include/DeckMetaData.h\ + include/GuiPhaseBar.h\ + include/ReplacementEffects.h\ + include/WGui.h\ + include/DeckStats.h\ + include/GuiPlay.h\ + include/Rules.h\ + include/WResourceManager.h\ + include/DuelLayers.h\ + include/GuiStatic.h\ + include/Effects.h\ + include/StyleManager.h\ + include/WFont.h\ + include/DeckManager.h\ + include/SimplePopup.h\ + include/SimpleMenu.h\ + include/PrecompiledHeader.h\ + include/Navigator.h\ + include/DeckEditorMenu.h\ + include/PlayRestrictions.h\ + include/NetworkPlayer.h + +# JGE, could probably be moved outside +SOURCES += \ + ../../JGE/src/SDLmain.cpp\ + ../../JGE/src/Encoding.cpp\ + ../../JGE/src/JAnimator.cpp\ + ../../JGE/src/JApp.cpp\ + ../../JGE/src/JDistortionMesh.cpp\ + ../../JGE/src/JFileSystem.cpp\ + ../../JGE/src/JGameObject.cpp\ + ../../JGE/src/JGE.cpp\ + ../../JGE/src/JGui.cpp\ + ../../JGE/src/JLogger.cpp\ + ../../JGE/src/JLBFont.cpp\ + ../../JGE/src/JMD2Model.cpp\ + ../../JGE/src/JOBJModel.cpp\ + ../../JGE/src/JParticle.cpp\ + ../../JGE/src/JParticleEffect.cpp\ + ../../JGE/src/JParticleEmitter.cpp\ + ../../JGE/src/JParticleSystem.cpp\ + ../../JGE/src/JResourceManager.cpp\ + ../../JGE/src/JSpline.cpp\ + ../../JGE/src/JSprite.cpp\ + ../../JGE/src/Vector2D.cpp\ + ../../JGE/src/tinyxml/tinystr.cpp\ + ../../JGE/src/tinyxml/tinyxml.cpp\ + ../../JGE/src/tinyxml/tinyxmlerror.cpp\ + ../../JGE/src/tinyxml/tinyxmlparser.cpp\ + ../../JGE/src/hge/hgecolor.cpp\ + ../../JGE/src/hge/hgedistort.cpp\ + ../../JGE/src/hge/hgefont.cpp\ + ../../JGE/src/hge/hgeparticle.cpp\ + ../../JGE/src/hge/hgerect.cpp\ + ../../JGE/src/hge/hgevector.cpp\ + ../../JGE/src/unzip/ioapi.c\ + ../../JGE/src/unzip/mztools.c\ + ../../JGE/src/unzip/unzip.c\ + ../../JGE/src/pc/JSfx.cpp\ + ../../JGE/src/pc/JGfx.cpp\ + ../../JGE/src/JNetwork.cpp\ + ../../JGE/src/pc/JSocket.cpp + +HEADERS += \ + ../../JGE/include/decoder_prx.h\ + ../../JGE/include/DebugRoutines.h\ + ../../JGE/include/Encoding.h\ + ../../JGE/include/JAnimator.h\ + ../../JGE/include/JApp.h\ + ../../JGE/include/JAssert.h\ + ../../JGE/include/JCooleyesMP3.h\ + ../../JGE/include/JDistortionMesh.h\ + ../../JGE/include/JFileSystem.h\ + ../../JGE/include/JGameLauncher.h\ + ../../JGE/include/JGameObject.h\ + ../../JGE/include/JGE.h\ + ../../JGE/include/JGui.h\ + ../../JGE/include/JLBFont.h\ + ../../JGE/include/JLogger.h\ + ../../JGE/include/JMD2Model.h\ + ../../JGE/include/JMP3.h\ + ../../JGE/include/JNetwork.h\ + ../../JGE/include/JOBJModel.h\ + ../../JGE/include/JParticleEffect.h\ + ../../JGE/include/JParticleEmitter.h\ + ../../JGE/include/JParticle.h\ + ../../JGE/include/JParticleSystem.h\ + ../../JGE/include/JRenderer.h\ + ../../JGE/include/JResourceManager.h\ + ../../JGE/include/JSocket.h\ + ../../JGE/include/JSoundSystem.h\ + ../../JGE/include/JSpline.h\ + ../../JGE/include/JSprite.h\ + ../../JGE/include/JTypes.h\ + ../../JGE/include/Vector2D.h\ + ../../JGE/include/Vector3D.h\ + ../../JGE/include/vram.h\ + ../../JGE/include/Threading.h\ + ../../JGE/src/tinyxml/tinystr.h\ + ../../JGE/src/tinyxml/tinyxml.h\ + ../../JGE/include/vram.h\ + ../../JGE/include/hge/hgecolor.h\ + ../../JGE/include/hge/hgedistort.h\ + ../../JGE/include/hge/hgefont.h\ + ../../JGE/include/hge/hgerect.h\ + ../../JGE/include/hge/hgevector.h\ + ../../JGE/include/hge/hgeparticle.h\ + ../../JGE/include/unzip/ioapi.h\ + ../../JGE/include/unzip/mztools.h\ + ../../JGE/include/unzip/unzip.h\ + ../../JGE/include/JNetwork.h\ + ../../JGE/include/JSocket.h + + INSTALLS += target \ + res \ + + res.path = /usr/local/bin/Res + res.files += bin/Res/* + target.path = /usr/local/bin + +maemo5: { + # Variables + BINDIR = /opt/wagic + RESDIR = /home/user/wagic/Res + ICONDIR = /usr/share + DEFINES += RESDIR=\\\"$$RESDIR\\\" + + INSTALLS += target \ + desktop \ + icon \ + res \ + restxt \ + launcher \ + + target.path = $$BINDIR + + desktop.path = $$ICONDIR/applications/hildon + desktop.files += wagic.desktop + + icon.path = $$ICONDIR/icons/hicolor/64x64/apps + icon.files += wagic-64x64.png + + res.path = $$RESDIR + res.files += bin/Res/* + # res.extra = tar -C ../../../../src/projects/mtg/bin -czf Res.tgz Res + + restxt.path = $$BINDIR + restxt.files += debian/Res.txt + + launcher.path = $$BINDIR + launcher.files += debian/launcher +}