diff --git a/JGE/include/JRenderer.h b/JGE/include/JRenderer.h index e2bda765e..d8feda767 100644 --- a/JGE/include/JRenderer.h +++ b/JGE/include/JRenderer.h @@ -53,6 +53,12 @@ #define COSF(x) cosf(x*DEG2RAD) #endif +#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) || (defined WIN32) +typedef struct +{ + GLfloat m[4][4]; +} ESMatrix; +#endif // (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) ////////////////////////////////////////////////////////////////////////// /// A collection of core rendering functions. @@ -541,8 +547,32 @@ private: #if defined (WIN32) || defined (LINUX) GLuint mCurrentTex; +#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) || (defined WIN32) + // MVP matrix + ESMatrix theMvpMatrix; + // Handle to a program object + GLuint prog1; + // Attribute locations + GLint prog1_positionLoc; + GLint prog1_colorLoc; + // Uniform locations + GLint prog1_mvpLoc; + // Handle to a program object + GLuint prog2; + // Sampler location + GLint prog2_samplerLoc; + // Attribute locations + GLint prog2_positionLoc; + GLint prog2_texCoordLoc; + GLint prog2_colorLoc; + // MVP matrix + ESMatrix prog2_mvpMatrix; + // Uniform locations + GLint prog2_mvpLoc; + +#endif // (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) #else void *fbp0, *fbp1, *zbp; PIXEL_TYPE* mVRAM; diff --git a/JGE/include/JSoundSystem.h b/JGE/include/JSoundSystem.h index 5ce12db70..b9c2ab1ff 100644 --- a/JGE/include/JSoundSystem.h +++ b/JGE/include/JSoundSystem.h @@ -19,6 +19,10 @@ #include "JTypes.h" +#ifdef USE_PHONON +#include +#include +#else #ifdef WIN32 #include @@ -43,16 +47,31 @@ #ifdef WITH_FMOD #include "../Dependencies/include/fmod.h" #endif +#endif //------------------------------------------------------------------------------------------------ +#ifdef USE_PHONON +class JMusic : public QObject +{ + Q_OBJECT +#else class JMusic { +#endif public: JMusic(); - ~JMusic(); + ~JMusic(); void Update(); int getPlayTime(); +#ifdef USE_PHONON + Phonon::AudioOutput* mOutput; + Phonon::MediaObject* mMediaObject; + public slots: + void seekAtTheBegining(); + +#else + #if defined (WIN32) || defined (LINUX) #ifdef WITH_FMOD FSOUND_SAMPLE* mTrack; // MP3 needed to be of "sample" type for FMOD, FMUSIC_MODULE is for MODs @@ -62,6 +81,7 @@ public: #else JMP3* mTrack; #endif +#endif }; @@ -80,6 +100,10 @@ class JSample #ifdef WITH_FMOD FSOUND_SAMPLE *mSample; #else +#ifdef USE_PHONON + Phonon::AudioOutput* mOutput; + Phonon::MediaObject* mMediaObject; +#endif void* mSample; #endif #else diff --git a/JGE/include/JTypes.h b/JGE/include/JTypes.h index 767c9009e..86a35469c 100644 --- a/JGE/include/JTypes.h +++ b/JGE/include/JTypes.h @@ -39,11 +39,11 @@ #define MAX_CHANNEL 128 -enum { - JGE_ERR_CANT_OPEN_FILE = -1, - JGE_ERR_PNG = -2, - JGE_ERR_MALLOC_FAILED = -4, - JGE_ERR_GENERIC = -5, +enum { + JGE_ERR_CANT_OPEN_FILE = -1, + JGE_ERR_PNG = -2, + JGE_ERR_MALLOC_FAILED = -4, + JGE_ERR_GENERIC = -5, }; @@ -88,10 +88,14 @@ enum { typedef bool BOOL; #endif +#ifndef QT_CONFIG #if defined (WIN32) || defined (LINUX) #include #include #endif +#else +# include +#endif #if defined (WIN32) || defined (LINUX) diff --git a/JGE/lib/win/jge.lib b/JGE/lib/win/jge.lib index e88f29f18..8550724e1 100644 Binary files a/JGE/lib/win/jge.lib and b/JGE/lib/win/jge.lib differ diff --git a/JGE/src/JMD2Model.cpp b/JGE/src/JMD2Model.cpp index cb1879117..7d1f7cedd 100644 --- a/JGE/src/JMD2Model.cpp +++ b/JGE/src/JMD2Model.cpp @@ -245,7 +245,11 @@ void JMD2Model::CalculateNormal(ScePspFVector3 *normal, float *p1, float *p2, fl #if defined (WIN32) || defined (LINUX) // normalize and specify the normal +#if (!defined GL_ES_VERSION_2_0) && (!defined GL_VERSION_2_0) glNormal3f(result[0]/length, result[1]/length, result[2]/length); +#else + // FIXME +#endif //(!defined GL_ES_VERSION_2_0) && (!defined GL_VERSION_2_0) #else if (length == 0.0f) @@ -275,15 +279,45 @@ void JMD2Model::Render(int frameNum) #if defined (WIN32) || defined (LINUX) - // display the textured model with proper lighting normals - glBegin(GL_TRIANGLES); +#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) + +#elif (defined GL_ES_VERSION_1_1) || (defined GL_VERSION_1_1) + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + +#else + glBegin(GL_TRIANGLES); +#endif //(defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) + for(i = 0; i < mModel->numTriangles; i++) { CalculateNormal(pointList[mModel->triIndex[i].meshIndex[0]].v, pointList[mModel->triIndex[i].meshIndex[2]].v, pointList[mModel->triIndex[i].meshIndex[1]].v); - glTexCoord2f(mModel->st[mModel->triIndex[i].stIndex[0]].s, + +#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) + +#elif (defined GL_ES_VERSION_1_1) || (defined GL_VERSION_1_1) + float vertex_data[]={ + pointList[mModel->triIndex[i].meshIndex[0]].x, pointList[mModel->triIndex[i].meshIndex[0]].y, pointList[mModel->triIndex[i].meshIndex[0]].z, + pointList[mModel->triIndex[i].meshIndex[2]].x, pointList[mModel->triIndex[i].meshIndex[2]].y, pointList[mModel->triIndex[i].meshIndex[2]].z, + pointList[mModel->triIndex[i].meshIndex[1]].x, pointList[mModel->triIndex[i].meshIndex[1]].y, pointList[mModel->triIndex[i].meshIndex[1]].z, + }; + float texcoord_data[] = { + mModel->st[mModel->triIndex[i].stIndex[0]].s, + mModel->st[mModel->triIndex[i].stIndex[0]].t, + mModel->st[mModel->triIndex[i].stIndex[2]].s, + mModel->st[mModel->triIndex[i].stIndex[2]].t, + mModel->st[mModel->triIndex[i].stIndex[1]].s, + mModel->st[mModel->triIndex[i].stIndex[1]].t, + }; + + glVertexPointer(3,GL_FLOAT,0,vertex_data); + glTexCoordPointer(2,GL_FLOAT,0,texcoord_data); + +#else + glTexCoord2f(mModel->st[mModel->triIndex[i].stIndex[0]].s, mModel->st[mModel->triIndex[i].stIndex[0]].t); glVertex3fv(pointList[mModel->triIndex[i].meshIndex[0]].v); @@ -294,8 +328,15 @@ void JMD2Model::Render(int frameNum) glTexCoord2f(mModel->st[mModel->triIndex[i].stIndex[1]].s, mModel->st[mModel->triIndex[i].stIndex[1]].t); glVertex3fv(pointList[mModel->triIndex[i].meshIndex[1]].v); - } - glEnd(); +#endif //#if (!defined GL_ES_VERSION_2_0) && (!defined GL_VERSION_2_0) + } +#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) + +#elif (defined GL_ES_VERSION_1_1) || (defined GL_VERSION_1_1) + glDrawArrays(GL_TRIANGLES,0,3); // seems suspicious to put that here, should probably be in the loop +#else + glEnd(); +#endif //(defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) #else @@ -442,9 +483,16 @@ void JMD2Model::Render() #if defined (WIN32) || defined (LINUX) +#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) + // FIXME +#elif (defined GL_ES_VERSION_1_1) || (defined GL_VERSION_1_1) + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); +#else + glBegin(GL_TRIANGLES); +#endif //(defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) - glBegin(GL_TRIANGLES); - for (i = 0; i < mModel->numTriangles; i++) + for (i = 0; i < mModel->numTriangles; i++) { // get first points of each frame x1 = pointList[mModel->triIndex[i].meshIndex[0]].x; @@ -489,19 +537,48 @@ void JMD2Model::Render() //CalculateNormal(vertex[0].v, vertex[2].v, vertex[1].v); // render properly textured triangle - glTexCoord2f(mModel->st[mModel->triIndex[i].stIndex[0]].s, - mModel->st[mModel->triIndex[i].stIndex[0]].t); - glVertex3fv(vertex[0].v); - glTexCoord2f(mModel->st[mModel->triIndex[i].stIndex[2]].s , - mModel->st[mModel->triIndex[i].stIndex[2]].t); - glVertex3fv(vertex[2].v); +#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) + // FIXME +#elif (defined GL_ES_VERSION_1_1) || (defined GL_VERSION_1_1) + float vertex_data[]={ + vertex[0].x, vertex[0].y, vertex[0].z, + vertex[2].x, vertex[2].y, vertex[2].z, + vertex[1].x, vertex[1].y, vertex[1].z, + }; + float texcoord_data[] = { + mModel->st[mModel->triIndex[i].stIndex[0]].s, + mModel->st[mModel->triIndex[i].stIndex[0]].t, + mModel->st[mModel->triIndex[i].stIndex[2]].s, + mModel->st[mModel->triIndex[i].stIndex[2]].t, + mModel->st[mModel->triIndex[i].stIndex[1]].s, + mModel->st[mModel->triIndex[i].stIndex[1]].t, + }; - glTexCoord2f(mModel->st[mModel->triIndex[i].stIndex[1]].s, - mModel->st[mModel->triIndex[i].stIndex[1]].t); - glVertex3fv(vertex[1].v); - } - glEnd(); + glVertexPointer(3,GL_FLOAT,0,vertex_data); + glTexCoordPointer(2,GL_FLOAT,0,texcoord_data); +#else + glTexCoord2f(mModel->st[mModel->triIndex[i].stIndex[0]].s, + mModel->st[mModel->triIndex[i].stIndex[0]].t); + glVertex3fv(vertex[0].v); + + glTexCoord2f(mModel->st[mModel->triIndex[i].stIndex[2]].s , + mModel->st[mModel->triIndex[i].stIndex[2]].t); + glVertex3fv(vertex[2].v); + + glTexCoord2f(mModel->st[mModel->triIndex[i].stIndex[1]].s, + mModel->st[mModel->triIndex[i].stIndex[1]].t); + glVertex3fv(vertex[1].v); +#endif //(defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) + + } +#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) + // FIXME +#elif (defined GL_ES_VERSION_1_1) || (defined GL_VERSION_1_1) + glDrawArrays(GL_TRIANGLES,0,3); // seems suspicious to put that here, should probably be in the loop +#else + glEnd(); +#endif //(defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) #else diff --git a/JGE/src/Qtmain.cpp b/JGE/src/Qtmain.cpp new file mode 100644 index 000000000..3f15186e0 --- /dev/null +++ b/JGE/src/Qtmain.cpp @@ -0,0 +1,272 @@ +#define GL_GLEXT_PROTOTYPES +#include +#include +#include "../include/JGE.h" +#include "../include/JTypes.h" +#include "../include/JApp.h" +#include "../include/JFileSystem.h" +#include "../include/JRenderer.h" +#include "../include/JGameLauncher.h" + +#define ACTUAL_SCREEN_WIDTH (SCREEN_WIDTH) +#define ACTUAL_SCREEN_HEIGHT (SCREEN_HEIGHT) +#define ACTUAL_RATIO ((GLfloat)ACTUAL_SCREEN_WIDTH / (GLfloat)ACTUAL_SCREEN_HEIGHT) + +class JGEQtRenderer : public QGLWidget +{ +// Q_OBJECT // must include this if you use Qt signals/slots + +public: + JGEQtRenderer(QWidget *parent); + +protected: + + void initializeGL(); + + void resizeGL(int w, int h); + + void paintGL(); + + void timerEvent( QTimerEvent* ); + + void keyPressEvent(QKeyEvent *event); + + void keyReleaseEvent(QKeyEvent *event); +}; + +uint64_t lastTickCount; +JGE* g_engine = NULL; +JApp* g_app = NULL; +JGameLauncher* g_launcher = NULL; +JGEQtRenderer *g_glwidget = NULL; + +static const struct { LocalKeySym keysym; JButton keycode; } gDefaultBindings[] = + { + { Qt::Key_Enter, JGE_BTN_MENU }, + { Qt::Key_Backspace, JGE_BTN_CTRL }, + { Qt::Key_Up, JGE_BTN_UP }, + { Qt::Key_Down, JGE_BTN_DOWN }, + { Qt::Key_Left, JGE_BTN_LEFT }, + { Qt::Key_Right, JGE_BTN_RIGHT }, + { Qt::Key_Space, JGE_BTN_OK }, + { Qt::Key_Tab, JGE_BTN_CANCEL }, + { Qt::Key_J, JGE_BTN_PRI }, + { Qt::Key_K, JGE_BTN_SEC }, + { Qt::Key_Q, JGE_BTN_PREV }, + { Qt::Key_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() +{ + QTime theTime = QTime::currentTime(); + return theTime.second() * 1000 + theTime.msec(); +} + +bool JGEToggleFullscreen() +{ + if(g_glwidget->isFullScreen()) + { + g_glwidget->showNormal(); + } + else + { + g_glwidget->showFullScreen(); + } + 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(); + QTime theTime = QTime::currentTime(); + lastTickCount = theTime.second() * 1000 + theTime.msec(); + + 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; +} + + +JGEQtRenderer::JGEQtRenderer(QWidget *parent) + : QGLWidget(QGLFormat(QGL::SampleBuffers), parent) +{ + startTimer( 5 ); + setWindowTitle(g_launcher->GetName()); +#ifdef Q_WS_MAEMO_5 + setAttribute(Qt::WA_Maemo5AutoOrientation); + setAttribute(Qt::WA_Maemo5NonComposited); +#endif +} + + +void JGEQtRenderer::initializeGL() +{ + 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 + glClearDepth(1.0f); // Depth Buffer Setup + + 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! + #endif + + glEnable(GL_CULL_FACE); // do not calculate inside of poly's + glFrontFace(GL_CCW); // counter clock-wise polygons are out + + glEnable(GL_TEXTURE_2D); + + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + + glEnable(GL_SCISSOR_TEST); // Enable Clipping +} + +int actualWidth; +int actualHeight; + +GLvoid ReSizeGLScene(GLsizei width, GLsizei height) // Resize The GL Window +{ + actualWidth = width; + actualHeight = height; + + if ((GLfloat)width / (GLfloat)height < ACTUAL_RATIO) + glViewport(0, -((width/ACTUAL_RATIO)-height)/2, width, width / ACTUAL_RATIO); // Reset The Current Viewport + else + glViewport(-(height*ACTUAL_RATIO-width)/2, 0, height * ACTUAL_RATIO, height); + glScissor(0, 0, width, height); +} + +void JGEQtRenderer::resizeGL(int width, int height) +{ + ReSizeGLScene(width, height); +} + +void JGEQtRenderer::paintGL() +{ + g_engine->Render(); +} + +void JGEQtRenderer::timerEvent( QTimerEvent* ) +{ + QTime theTime = QTime::currentTime(); + static uint64_t tickCount; + quint32 dt; + tickCount = theTime.second() * 1000 + theTime.msec(); + dt = (tickCount - lastTickCount); + lastTickCount = tickCount; + + if(g_engine->IsDone()) close(); + + //gPrevControllerState = gControllerState; + g_engine->SetDelta((float)dt / 1000.0f); + g_engine->Update((float)dt / 1000.0f); + + updateGL(); +} + + +void JGEQtRenderer::keyPressEvent(QKeyEvent *event) +{ + if(event->key() == Qt::Key_F) + { + JGEToggleFullscreen(); + } + g_engine->HoldKey_NoRepeat(event->key()); + event->accept(); + QWidget::keyPressEvent(event); + return; +} + +void JGEQtRenderer::keyReleaseEvent(QKeyEvent *event) +{ + g_engine->ReleaseKey(event->key()); + event->accept(); + QWidget::keyReleaseEvent(event); + return; +} + + +int main(int argc, char* argv[]) +{ + char* path = argv[0]; + while (*path) ++path; + while ((*path != '/') && (path > argv[0])) --path; + if ('/' == *path) *path = 0; + if (strlen(argv[0]) != 0) QDir::current().cd(argv[0]); + + QApplication a( argc, argv ); + + g_launcher = new JGameLauncher(); + + u32 flags = g_launcher->GetInitFlags(); + + if ((flags&JINIT_FLAG_ENABLE3D)!=0) + JRenderer::Set3DFlag(true); + + g_glwidget = new JGEQtRenderer(NULL); + + g_glwidget->resize(ACTUAL_SCREEN_WIDTH, ACTUAL_SCREEN_HEIGHT); + + g_glwidget->show(); + + if (!InitGame()) + { + printf("Could not init the game\n"); + return 1; + } + + JGECreateDefaultBindings(); + + a.exec(); + + if (g_launcher) + delete g_launcher; + + if(g_glwidget) + delete g_glwidget; + + // Shutdown + DestroyGame(); + return 0; +} diff --git a/JGE/src/main.cpp b/JGE/src/main.cpp index 4bf8e1a44..59d2dc704 100644 --- a/JGE/src/main.cpp +++ b/JGE/src/main.cpp @@ -112,7 +112,7 @@ int SetupCallbacks(void) #ifdef DEVHOOK //code by sakya, crazyc, samuraiX -//http://forums.ps2dev.org/viewtopic.php?t=9591&sid=2056889f6b9531194cab9b2d487df844 +//http://forums.ps2dev.org/viewtopic.php?t=9591 PspDebugRegBlock exception_regs; extern int _ftext; diff --git a/JGE/src/pc/JGfx.cpp b/JGE/src/pc/JGfx.cpp index 0836e7aa4..c17435938 100644 --- a/JGE/src/pc/JGfx.cpp +++ b/JGE/src/pc/JGfx.cpp @@ -7,6 +7,7 @@ // Copyright (c) 2007 James Hui (a.k.a. Dr.Watson) // //------------------------------------------------------------------------------------- +#define GL_GLEXT_PROTOTYPES #ifdef WIN32 #pragma warning(disable : 4786) @@ -15,8 +16,7 @@ #pragma comment( lib, "giflib.lib" ) #endif - -#include "../../Dependencies/include/png.h" +#include #ifdef __cplusplus extern "C" { @@ -42,6 +42,237 @@ extern "C" { #endif #endif +#ifdef FORCE_GL2 +// This code is to force the windows code to use GL_VERSION_2_0 even if it's not defined in the header files +// It's mostly to try to debug the shaders on Windows. +typedef GLuint (APIENTRY *_glCreateShader) (GLenum); +typedef void (APIENTRY *_glShaderSource) (GLuint, GLsizei, const char **, const GLint *); +typedef void (APIENTRY *_glShaderBinary) (GLint, const GLuint*, GLenum, const void*, GLint); +typedef void (APIENTRY *_glCompileShader) (GLuint); +typedef void (APIENTRY *_glDeleteShader) (GLuint); +typedef GLboolean (APIENTRY *_glIsShader) (GLuint); + +typedef GLuint (APIENTRY *_glCreateProgram) (); +typedef void (APIENTRY *_glAttachShader) (GLuint, GLuint); +typedef void (APIENTRY *_glDetachShader) (GLuint, GLuint); +typedef void (APIENTRY *_glLinkProgram) (GLuint); +typedef void (APIENTRY *_glUseProgram) (GLuint); +typedef void (APIENTRY *_glDeleteProgram) (GLuint); +typedef GLboolean (APIENTRY *_glIsProgram) (GLuint); + +typedef void (APIENTRY *_glGetShaderInfoLog) (GLuint, GLsizei, GLsizei *, char *); +typedef void (APIENTRY *_glGetShaderiv) (GLuint, GLenum, GLint *); +typedef void (APIENTRY *_glGetShaderSource) (GLuint, GLsizei, GLsizei *, char *); +typedef void (APIENTRY *_glGetProgramiv) (GLuint, GLenum, GLint *); +typedef void (APIENTRY *_glGetProgramInfoLog) (GLuint, GLsizei, GLsizei *, char *); + +typedef GLuint (APIENTRY *_glGetUniformLocation) (GLuint, const char*); +typedef void (APIENTRY *_glUniform4fv) (GLint, GLsizei, const GLfloat *); +typedef void (APIENTRY *_glUniform3fv) (GLint, GLsizei, const GLfloat *); +typedef void (APIENTRY *_glUniform2fv) (GLint, GLsizei, const GLfloat *); +typedef void (APIENTRY *_glUniform1fv) (GLint, GLsizei, const GLfloat *); +typedef void (APIENTRY *_glUniform1i) (GLint, GLint); +typedef void (APIENTRY *_glUniform1iv) (GLint, GLsizei, const GLint *); +typedef void (APIENTRY *_glUniformMatrix2fv) (GLint, GLsizei, GLboolean, const GLfloat *); +typedef void (APIENTRY *_glUniformMatrix3fv) (GLint, GLsizei, GLboolean, const GLfloat *); +typedef void (APIENTRY *_glUniformMatrix4fv) (GLint, GLsizei, GLboolean, const GLfloat *); +typedef void (APIENTRY *_glUniformMatrix2x3fv) (GLint, GLsizei, GLboolean, const GLfloat *); +typedef void (APIENTRY *_glUniformMatrix2x4fv) (GLint, GLsizei, GLboolean, const GLfloat *); +typedef void (APIENTRY *_glUniformMatrix3x2fv) (GLint, GLsizei, GLboolean, const GLfloat *); +typedef void (APIENTRY *_glUniformMatrix3x4fv) (GLint, GLsizei, GLboolean, const GLfloat *); +typedef void (APIENTRY *_glUniformMatrix4x2fv) (GLint, GLsizei, GLboolean, const GLfloat *); +typedef void (APIENTRY *_glUniformMatrix4x3fv) (GLint, GLsizei, GLboolean, const GLfloat *); + +typedef void (APIENTRY *_glBindAttribLocation) (GLuint, GLuint, const char *); +typedef GLint (APIENTRY *_glGetAttribLocation) (GLuint, const char *); +typedef void (APIENTRY *_glVertexAttrib1fv) (GLuint, const GLfloat *); +typedef void (APIENTRY *_glVertexAttrib2fv) (GLuint, const GLfloat *); +typedef void (APIENTRY *_glVertexAttrib3fv) (GLuint, const GLfloat *); +typedef void (APIENTRY *_glVertexAttrib4fv) (GLuint, const GLfloat *); +typedef void (APIENTRY *_glVertexAttribPointer) (GLuint, GLint, GLenum, GLboolean, GLsizei, const GLvoid *); +typedef void (APIENTRY *_glDisableVertexAttribArray) (GLuint); +typedef void (APIENTRY *_glEnableVertexAttribArray) (GLuint); + +typedef void (APIENTRY *_glGetProgramBinaryOES) (GLuint, GLsizei, GLsizei *, GLenum *, void *); +typedef void (APIENTRY *_glProgramBinaryOES) (GLuint, GLenum, const void *, GLint); + + +typedef void (APIENTRY *_glMultiTexCoord4f) (GLenum, GLfloat, GLfloat, GLfloat, GLfloat); +typedef void (APIENTRY *_glActiveStencilFaceEXT) (GLenum ); + +typedef void (APIENTRY *_glStencilOpSeparate) (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +typedef void (APIENTRY *_glActiveTexture) (GLenum); +typedef void (APIENTRY *_glBlendColor) (GLclampf, GLclampf, GLclampf, GLclampf); + +#define GLSLGETPROC(func) a ## func = (_ ## func)wglGetProcAddress(#func); + +struct glslFunctions +{ + void load(){ + GLSLGETPROC(glCreateShader); + GLSLGETPROC(glShaderSource); + GLSLGETPROC(glShaderBinary); + GLSLGETPROC(glCompileShader); + GLSLGETPROC(glDeleteShader); + GLSLGETPROC(glIsShader); + GLSLGETPROC(glCreateProgram); + GLSLGETPROC(glAttachShader); + GLSLGETPROC(glDetachShader); + GLSLGETPROC(glLinkProgram); + GLSLGETPROC(glUseProgram); + GLSLGETPROC(glDeleteProgram); + GLSLGETPROC(glIsProgram); + GLSLGETPROC(glGetShaderInfoLog); + GLSLGETPROC(glGetShaderiv); + GLSLGETPROC(glGetShaderSource); + GLSLGETPROC(glGetProgramiv); + GLSLGETPROC(glGetProgramInfoLog); + GLSLGETPROC(glGetUniformLocation); + GLSLGETPROC(glUniform4fv); + GLSLGETPROC(glUniform3fv); + GLSLGETPROC(glUniform2fv); + GLSLGETPROC(glUniform1fv); + GLSLGETPROC(glUniform1i); + GLSLGETPROC(glUniform1iv); + GLSLGETPROC(glUniformMatrix2fv); + GLSLGETPROC(glUniformMatrix3fv); + GLSLGETPROC(glUniformMatrix4fv); + GLSLGETPROC(glUniformMatrix2x3fv); + GLSLGETPROC(glUniformMatrix2x4fv); + GLSLGETPROC(glUniformMatrix3x2fv); + GLSLGETPROC(glUniformMatrix3x4fv); + GLSLGETPROC(glUniformMatrix4x2fv); + GLSLGETPROC(glUniformMatrix4x3fv); + GLSLGETPROC(glBindAttribLocation); + GLSLGETPROC(glGetAttribLocation); + GLSLGETPROC(glVertexAttrib1fv); + GLSLGETPROC(glVertexAttrib2fv); + GLSLGETPROC(glVertexAttrib3fv); + GLSLGETPROC(glVertexAttrib4fv); + GLSLGETPROC(glVertexAttribPointer); + GLSLGETPROC(glDisableVertexAttribArray); + GLSLGETPROC(glEnableVertexAttribArray); + GLSLGETPROC(glGetProgramBinaryOES); + GLSLGETPROC(glProgramBinaryOES); + GLSLGETPROC(glMultiTexCoord4f); + GLSLGETPROC(glActiveStencilFaceEXT); + GLSLGETPROC(glStencilOpSeparate); + GLSLGETPROC(glActiveTexture); + GLSLGETPROC(glBlendColor); + }; + + _glCreateShader aglCreateShader; + _glShaderSource aglShaderSource; + _glShaderBinary aglShaderBinary; + _glCompileShader aglCompileShader; + _glDeleteShader aglDeleteShader; + _glIsShader aglIsShader; + _glCreateProgram aglCreateProgram; + _glAttachShader aglAttachShader; + _glDetachShader aglDetachShader; + _glLinkProgram aglLinkProgram; + _glUseProgram aglUseProgram; + _glDeleteProgram aglDeleteProgram; + _glIsProgram aglIsProgram; + _glGetShaderInfoLog aglGetShaderInfoLog; + _glGetShaderiv aglGetShaderiv; + _glGetShaderSource aglGetShaderSource; + _glGetProgramiv aglGetProgramiv; + _glGetProgramInfoLog aglGetProgramInfoLog; + + _glGetUniformLocation aglGetUniformLocation; + _glUniform4fv aglUniform4fv; + _glUniform3fv aglUniform3fv; + _glUniform2fv aglUniform2fv; + _glUniform1fv aglUniform1fv; + _glUniform1i aglUniform1i; + _glUniform1iv aglUniform1iv; + _glUniformMatrix2fv aglUniformMatrix2fv; + _glUniformMatrix3fv aglUniformMatrix3fv; + _glUniformMatrix4fv aglUniformMatrix4fv; + _glUniformMatrix2x3fv aglUniformMatrix2x3fv; + _glUniformMatrix2x4fv aglUniformMatrix2x4fv; + _glUniformMatrix3x2fv aglUniformMatrix3x2fv; + _glUniformMatrix3x4fv aglUniformMatrix3x4fv; + _glUniformMatrix4x2fv aglUniformMatrix4x2fv; + _glUniformMatrix4x3fv aglUniformMatrix4x3fv; + + _glBindAttribLocation aglBindAttribLocation; + _glGetAttribLocation aglGetAttribLocation; + _glVertexAttrib1fv aglVertexAttrib1fv; + _glVertexAttrib2fv aglVertexAttrib2fv; + _glVertexAttrib3fv aglVertexAttrib3fv; + _glVertexAttrib4fv aglVertexAttrib4fv; + _glVertexAttribPointer aglVertexAttribPointer; + _glDisableVertexAttribArray aglDisableVertexAttribArray; + _glEnableVertexAttribArray aglEnableVertexAttribArray; + + _glGetProgramBinaryOES aglGetProgramBinaryOES; + _glProgramBinaryOES aglProgramBinaryOES; + _glMultiTexCoord4f aglMultiTexCoord4f; + _glActiveStencilFaceEXT aglActiveStencilFaceEXT; + _glStencilOpSeparate aglStencilOpSeparate; + _glActiveTexture aglActiveTexture; + _glBlendColor aglBlendColor; +}; + +static glslFunctions g_glslfuncts; + +#define glCreateShader g_glslfuncts.aglCreateShader +#define glCompileShader g_glslfuncts.aglCompileShader +#define glGetShaderiv g_glslfuncts.aglGetShaderiv +#define glGetShaderInfoLog g_glslfuncts.aglGetShaderInfoLog +#define glDeleteShader g_glslfuncts.aglDeleteShader +#define glCreateProgram g_glslfuncts.aglCreateProgram +#define glDeleteProgram g_glslfuncts.aglDeleteProgram +#define glShaderSource g_glslfuncts.aglShaderSource +#define glAttachShader g_glslfuncts.aglAttachShader +#define glLinkProgram g_glslfuncts.aglLinkProgram +#define glGetProgramiv g_glslfuncts.aglGetProgramiv +#define glGetProgramInfoLog g_glslfuncts.aglGetProgramInfoLog +#define glGetAttribLocation g_glslfuncts.aglGetAttribLocation +#define glGetUniformLocation g_glslfuncts.aglGetUniformLocation +#define glGetProgramiv g_glslfuncts.aglGetProgramiv +#define glVertexAttribPointer g_glslfuncts.aglVertexAttribPointer +#define glEnableVertexAttribArray g_glslfuncts.aglEnableVertexAttribArray +#define glUniform4fv g_glslfuncts.aglUniform4fv +#define glActiveTexture g_glslfuncts.aglActiveTexture +#define glUniform1i g_glslfuncts.aglUniform1i +#define glUseProgram g_glslfuncts.aglUseProgram +#define glUniformMatrix4fv g_glslfuncts.aglUniformMatrix4fv + +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 + +#define GL_VERSION_2_0 +#endif + JQuad::JQuad(JTexture *tex, float x, float y, float width, float height) :mTex(tex), mX(x), mY(y), mWidth(width), mHeight(height) { @@ -160,6 +391,265 @@ JRenderer::~JRenderer() } +#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) +void esMatrixLoadIdentity(ESMatrix *result) +{ + memset(result, 0x0, sizeof(ESMatrix)); + result->m[0][0] = 1.0f; + result->m[1][1] = 1.0f; + result->m[2][2] = 1.0f; + result->m[3][3] = 1.0f; +} + +#define PI 3.1415926535897932384626433832795f + +void esScale(ESMatrix *result, GLfloat sx, GLfloat sy, GLfloat sz) +{ + result->m[0][0] *= sx; + result->m[0][1] *= sx; + result->m[0][2] *= sx; + result->m[0][3] *= sx; + + result->m[1][0] *= sy; + result->m[1][1] *= sy; + result->m[1][2] *= sy; + result->m[1][3] *= sy; + + result->m[2][0] *= sz; + result->m[2][1] *= sz; + result->m[2][2] *= sz; + result->m[2][3] *= sz; +} + +void esTranslate(ESMatrix *result, GLfloat tx, GLfloat ty, GLfloat tz) +{ + result->m[3][0] += (result->m[0][0] * tx + result->m[1][0] * ty + result->m[2][0] * tz); + result->m[3][1] += (result->m[0][1] * tx + result->m[1][1] * ty + result->m[2][1] * tz); + result->m[3][2] += (result->m[0][2] * tx + result->m[1][2] * ty + result->m[2][2] * tz); + result->m[3][3] += (result->m[0][3] * tx + result->m[1][3] * ty + result->m[2][3] * tz); +} + +void esMatrixMultiply(ESMatrix *result, ESMatrix *srcA, ESMatrix *srcB) +{ + ESMatrix tmp; + int i; + + for (i=0; i<4; i++) + { + tmp.m[i][0] = (srcA->m[i][0] * srcB->m[0][0]) + + (srcA->m[i][1] * srcB->m[1][0]) + + (srcA->m[i][2] * srcB->m[2][0]) + + (srcA->m[i][3] * srcB->m[3][0]) ; + + tmp.m[i][1] = (srcA->m[i][0] * srcB->m[0][1]) + + (srcA->m[i][1] * srcB->m[1][1]) + + (srcA->m[i][2] * srcB->m[2][1]) + + (srcA->m[i][3] * srcB->m[3][1]) ; + + tmp.m[i][2] = (srcA->m[i][0] * srcB->m[0][2]) + + (srcA->m[i][1] * srcB->m[1][2]) + + (srcA->m[i][2] * srcB->m[2][2]) + + (srcA->m[i][3] * srcB->m[3][2]) ; + + tmp.m[i][3] = (srcA->m[i][0] * srcB->m[0][3]) + + (srcA->m[i][1] * srcB->m[1][3]) + + (srcA->m[i][2] * srcB->m[2][3]) + + (srcA->m[i][3] * srcB->m[3][3]) ; + } + memcpy(result, &tmp, sizeof(ESMatrix)); +} + +void esRotate(ESMatrix *result, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + GLfloat sinAngle, cosAngle; + GLfloat mag = sqrtf(x * x + y * y + z * z); + + sinAngle = sinf ( angle * PI / 180.0f ); + cosAngle = cosf ( angle * PI / 180.0f ); + if ( mag > 0.0f ) + { + GLfloat xx, yy, zz, xy, yz, zx, xs, ys, zs; + GLfloat oneMinusCos; + ESMatrix rotMat; + + x /= mag; + y /= mag; + z /= mag; + + xx = x * x; + yy = y * y; + zz = z * z; + xy = x * y; + yz = y * z; + zx = z * x; + xs = x * sinAngle; + ys = y * sinAngle; + zs = z * sinAngle; + oneMinusCos = 1.0f - cosAngle; + + rotMat.m[0][0] = (oneMinusCos * xx) + cosAngle; + rotMat.m[0][1] = (oneMinusCos * xy) - zs; + rotMat.m[0][2] = (oneMinusCos * zx) + ys; + rotMat.m[0][3] = 0.0F; + + rotMat.m[1][0] = (oneMinusCos * xy) + zs; + rotMat.m[1][1] = (oneMinusCos * yy) + cosAngle; + rotMat.m[1][2] = (oneMinusCos * yz) - xs; + rotMat.m[1][3] = 0.0F; + + rotMat.m[2][0] = (oneMinusCos * zx) - ys; + rotMat.m[2][1] = (oneMinusCos * yz) + xs; + rotMat.m[2][2] = (oneMinusCos * zz) + cosAngle; + rotMat.m[2][3] = 0.0F; + + rotMat.m[3][0] = 0.0F; + rotMat.m[3][1] = 0.0F; + rotMat.m[3][2] = 0.0F; + rotMat.m[3][3] = 1.0F; + + esMatrixMultiply( result, &rotMat, result ); + } +} + +void esOrtho(ESMatrix *result, float left, float right, float bottom, float top, float nearZ, float farZ) +{ + float deltaX = right - left; + float deltaY = top - bottom; + float deltaZ = farZ - nearZ; + ESMatrix ortho; + + if ( (deltaX == 0.0f) || (deltaY == 0.0f) || (deltaZ == 0.0f) ) + return; + + esMatrixLoadIdentity(&ortho); + ortho.m[0][0] = 2.0f / deltaX; + ortho.m[3][0] = -(right + left) / deltaX; + ortho.m[1][1] = 2.0f / deltaY; + ortho.m[3][1] = -(top + bottom) / deltaY; + ortho.m[2][2] = -2.0f / deltaZ; + ortho.m[3][2] = -(nearZ + farZ) / deltaZ; + + esMatrixMultiply(result, &ortho, result); +} + +/// \brief Load a shader, check for compile errors, print error messages to output log +/// \param type Type of shader (GL_VERTEX_SHADER or GL_FRAGMENT_SHADER) +/// \param shaderSrc Shader source string +/// \return A new shader object on success, 0 on failure +// +GLuint esLoadShader ( GLenum type, const char *shaderSrc ) +{ + GLuint shader; + GLint compiled; + + // Create the shader object + shader = glCreateShader ( type ); + + if ( shader == 0 ) + return 0; + + // Load the shader source + glShaderSource ( shader, 1, &shaderSrc, NULL ); + + // Compile the shader + glCompileShader ( shader ); + + // Check the compile status + glGetShaderiv ( shader, GL_COMPILE_STATUS, &compiled ); + + if ( !compiled ) + { + GLint infoLen = 0; + + glGetShaderiv ( shader, GL_INFO_LOG_LENGTH, &infoLen ); + + if ( infoLen > 1 ) + { + char* infoLog = (char*)malloc (sizeof(char) * infoLen ); + + glGetShaderInfoLog ( shader, infoLen, NULL, infoLog ); + printf ( "Error compiling shader:\n%s\n", infoLog ); + + free ( infoLog ); + } + + glDeleteShader ( shader ); + return 0; + } + + return shader; + +} + + +/// \brief Load a vertex and fragment shader, create a program object, link program. +// Errors output to log. +/// \param vertShaderSrc Vertex shader source code +/// \param fragShaderSrc Fragment shader source code +/// \return A new program object linked with the vertex/fragment shader pair, 0 on failure +// +GLuint esLoadProgram ( const char *vertShaderSrc, const char *fragShaderSrc ) +{ + GLuint vertexShader; + GLuint fragmentShader; + GLuint programObject; + GLint linked; + + // Load the vertex/fragment shaders + vertexShader = esLoadShader ( GL_VERTEX_SHADER, vertShaderSrc ); + if ( vertexShader == 0 ) + return 0; + + fragmentShader = esLoadShader ( GL_FRAGMENT_SHADER, fragShaderSrc ); + if ( fragmentShader == 0 ) + { + glDeleteShader( vertexShader ); + return 0; + } + + // Create the program object + programObject = glCreateProgram ( ); + + if ( programObject == 0 ) + return 0; + + glAttachShader ( programObject, vertexShader ); + glAttachShader ( programObject, fragmentShader ); + + // Link the program + glLinkProgram ( programObject ); + + // Check the link status + glGetProgramiv ( programObject, GL_LINK_STATUS, &linked ); + + if ( !linked ) + { + GLint infoLen = 0; + + glGetProgramiv ( programObject, GL_INFO_LOG_LENGTH, &infoLen ); + + if ( infoLen > 1 ) + { + char* infoLog = (char*)malloc (sizeof(char) * infoLen ); + + glGetProgramInfoLog ( programObject, infoLen, NULL, infoLog ); + printf( "Error linking program:\n%s\n", infoLog ); + + free ( infoLog ); + } + + glDeleteProgram ( programObject ); + return 0; + } + + // Free up no longer needed shader resources + glDeleteShader ( vertexShader ); + glDeleteShader ( fragmentShader ); + + return programObject; +} + +#endif /* GL_ES_VERSION_2_0 || GL_VERSION_2_0*/ void JRenderer::InitRenderer() { @@ -182,17 +672,98 @@ void JRenderer::InitRenderer() #endif mCurrentRenderMode = MODE_UNKNOWN; + + +#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) +#ifdef FORCE_GL2 + g_glslfuncts.load(); +#endif //FORCE_GL2 + + char vShader[] = + "uniform mat4 u_mvp_matrix; \n" + "attribute vec4 a_position; \n" + "attribute vec4 a_color; \n" + "varying vec4 v_color; \n" + "void main() \n" + "{ \n" + " gl_Position = u_mvp_matrix*a_position; \n" + " v_color = a_color; \n" + "} \n"; + char fShader[] = +#ifdef GL_ES_VERSION_2_0 // This line works fine on Windows, but not on Linux and it's required for GL_ES_2... hoh well + "precision mediump float; \n" +#endif //GL_ES_VERSION_2_0 + "varying vec4 v_color; \n" + "void main() \n" + "{ \n" + " gl_FragColor = v_color; \n" + "} \n"; + char vShaderWithTexture[] = + "uniform mat4 u_mvp_matrix; \n" + "attribute vec4 a_position; \n" + "attribute vec2 a_texCoord; \n" + "attribute vec4 a_color; \n" + "varying vec2 v_texCoord; \n" + "varying vec4 v_color; \n" + "void main() \n" + "{ \n" + " gl_Position = u_mvp_matrix*a_position; \n" + " v_texCoord = a_texCoord; \n" + " v_color = a_color; \n" + "} \n"; + char fShaderWithTexture[] = +#ifdef GL_ES_VERSION_2_0 // This line works fine on Windows, but not on Linux and it's required for GL_ES_2... hoh well + "precision mediump float; \n" +#endif //GL_ES_VERSION_2_0 + "varying vec2 v_texCoord; \n" + "varying vec4 v_color; \n" + "uniform sampler2D s_texture; \n" + "void main() \n" + "{ \n" + " vec4 texColor; \n" + " texColor = texture2D(s_texture, v_texCoord); \n" + " gl_FragColor = v_color*texColor; \n" + "} \n"; + + // Load the vertex/fragment shaders + prog1 = esLoadProgram(vShader, fShader); + // Get the attribute locations + prog1_positionLoc = glGetAttribLocation ( prog1, "a_position" ); + prog1_colorLoc = glGetAttribLocation ( prog1, "a_color" ); + // Get the uniform locations + prog1_mvpLoc = glGetUniformLocation( prog1, "u_mvp_matrix" ); + + // Load the vertex/fragment shaders + prog2 = esLoadProgram(vShaderWithTexture, fShaderWithTexture); + // Get the attribute locations + prog2_positionLoc = glGetAttribLocation ( prog2, "a_position" ); + prog2_texCoordLoc = glGetAttribLocation ( prog2, "a_texCoord" ); + prog2_colorLoc = glGetAttribLocation ( prog2, "a_color" ); + // Get the uniform locations + prog2_mvpLoc = glGetUniformLocation( prog2, "u_mvp_matrix" ); + // Get the sampler location + prog2_samplerLoc = glGetUniformLocation ( prog2, "s_texture" ); +#endif //(defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) } void JRenderer::DestroyRenderer() { - +#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) + // Delete program object + glDeleteProgram ( prog1 ); + glDeleteProgram ( prog2 ); +#endif //(defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) } void JRenderer::BeginScene() { glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear Screen And Depth Buffer - glLoadIdentity (); // Reset The Modelview Matrix +#if (!defined GL_ES_VERSION_2_0) && (!defined GL_VERSION_2_0) + glLoadIdentity (); // Reset The Modelview Matrix +#else + esMatrixLoadIdentity(&theMvpMatrix); + esOrtho(&theMvpMatrix, 0.0f, SCREEN_WIDTH_F, 0.0f, SCREEN_HEIGHT_F-1.0f,-1.0f, 1.0f); +#endif //(!defined GL_ES_VERSION_2_0) && (!defined GL_VERSION_2_0) #ifdef WIN32 float scaleH = (float)actualHeight/SCREEN_HEIGHT_F; float scaleW = (float)actualWidth/SCREEN_WIDTH_F; @@ -212,6 +783,7 @@ void JRenderer::BindTexture(JTexture *tex) if (mCurrentTex != tex->mTexId) { mCurrentTex = tex->mTexId; + glBindTexture(GL_TEXTURE_2D, tex->mTexId); //if (mCurrentTextureFilter != tex->mFilter) @@ -249,7 +821,6 @@ void Swap(float *a, float *b) *b = n; } - void JRenderer::RenderQuad(JQuad* quad, float xo, float yo, float angle, float xScale, float yScale) { //yo = SCREEN_HEIGHT-yo-1;//-(quad->mHeight); @@ -283,10 +854,6 @@ void JRenderer::RenderQuad(JQuad* quad, float xo, float yo, float angle, float x Swap(&uv[1].y, &uv[3].y); } - - //glEnable(GL_BLEND); - //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - BindTexture(quad->mTex); @@ -295,35 +862,133 @@ void JRenderer::RenderQuad(JQuad* quad, float xo, float yo, float angle, float x yo = SCREEN_HEIGHT_F - yo; - glPushMatrix(); - glTranslatef(xo, yo, 0.0f); - glRotatef(-angle*RAD2DEG, 0.0f, 0.0f, 1.0f); - glScalef(xScale, yScale, 1.0f); - glBegin(GL_QUADS); - // bottom left corner - glColor4ub(quad->mColor[0].r, quad->mColor[0].g, quad->mColor[0].b, quad->mColor[0].a); - glTexCoord2f(uv[0].x, uv[0].y); glVertex2f(pt[0].x, pt[0].y); +#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) + ESMatrix mvpMatrix; + memcpy(&mvpMatrix, &theMvpMatrix, sizeof(ESMatrix)); - // bottom right corner - glColor4ub(quad->mColor[1].r, quad->mColor[1].g, quad->mColor[1].b, quad->mColor[1].a); - glTexCoord2f(uv[1].x, uv[1].y); glVertex2f(pt[1].x, pt[1].y); + esTranslate(&mvpMatrix, xo, yo, 0.0f); + esRotate(&mvpMatrix, -angle*RAD2DEG, 0.0f, 0.0f, 1.0f); + esScale(&mvpMatrix, xScale, yScale, 1.0f); - // top right corner - glColor4ub(quad->mColor[2].r, quad->mColor[2].g, quad->mColor[2].b, quad->mColor[2].a); - glTexCoord2f(uv[2].x, uv[2].y); glVertex2f(pt[2].x, pt[2].y); + GLfloat vVertices[] = { + pt[0].x, pt[0].y, 0.0f, + uv[0].x, uv[0].y, + pt[1].x, pt[1].y, 0.0f, + uv[1].x, uv[1].y, + pt[3].x, pt[3].y, 0.0f, + uv[3].x, uv[3].y, + pt[2].x, pt[2].y, 0.0f, + uv[2].x, uv[2].y, + }; - // top left corner - glColor4ub(quad->mColor[3].r, quad->mColor[3].g, quad->mColor[3].b, quad->mColor[3].a); - glTexCoord2f(uv[3].x, uv[3].y); glVertex2f(pt[3].x, pt[3].y); - glEnd(); + 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, + }; - glPopMatrix(); + // Use the program object + glUseProgram ( prog2 ); + + // Load the vertex position + glVertexAttribPointer ( prog2_positionLoc, 3, GL_FLOAT, + GL_FALSE, 5 * sizeof(GLfloat), vVertices ); + // Load the texture coordinate + glVertexAttribPointer ( prog2_texCoordLoc, 2, GL_FLOAT, + GL_FALSE, 5 * sizeof(GLfloat), &vVertices[3] ); + // Load the colors + glVertexAttribPointer ( prog2_colorLoc, 4, GL_UNSIGNED_BYTE, + GL_TRUE, 4 * sizeof(GLubyte), colorCoords ); + + glEnableVertexAttribArray ( prog2_positionLoc ); + glEnableVertexAttribArray ( prog2_texCoordLoc ); + glEnableVertexAttribArray ( prog2_colorLoc ); + + // Load the MVP matrix + glUniformMatrix4fv( prog2_mvpLoc, 1, GL_FALSE, (GLfloat*) &mvpMatrix.m[0][0] ); + + // Bind the texture + glActiveTexture ( GL_TEXTURE0 ); + glBindTexture ( GL_TEXTURE_2D, mCurrentTex ); + + // Set the sampler texture unit to 0 + glUniform1i ( prog2_samplerLoc, 0 ); + + //glDrawElements ( GL_TRIANGLE_STRIP, 6, GL_UNSIGNED_SHORT, indices ); + glDrawArrays(GL_TRIANGLE_STRIP,0,4); + +#else + glPushMatrix(); + glTranslatef(xo, yo, 0.0f); + 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) + 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 + glBegin(GL_QUADS); + + glColor4ub(quad->mColor[0].r, quad->mColor[0].g, quad->mColor[0].b, quad->mColor[0].a); + glTexCoord2f(uv[0].x, uv[0].y); glVertex2f(pt[0].x, pt[0].y); + + // bottom right corner + glColor4ub(quad->mColor[1].r, quad->mColor[1].g, quad->mColor[1].b, quad->mColor[1].a); + glTexCoord2f(uv[1].x, uv[1].y); glVertex2f(pt[1].x, pt[1].y); + + // top right corner + glColor4ub(quad->mColor[2].r, quad->mColor[2].g, quad->mColor[2].b, quad->mColor[2].a); + glTexCoord2f(uv[2].x, uv[2].y); glVertex2f(pt[2].x, pt[2].y); + + // top left corner + glColor4ub(quad->mColor[3].r, quad->mColor[3].g, quad->mColor[3].b, quad->mColor[3].a); + glTexCoord2f(uv[3].x, uv[3].y); glVertex2f(pt[3].x, pt[3].y); + + glEnd(); +#endif //(defined GL_ES_VERSION_1_1) || (defined GL_VERSION_1_1) + + glPopMatrix(); + + //glDisable(GL_BLEND); + + // default color + glColor4ub(255, 255, 255, 255); +#endif //(defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) - //glDisable(GL_BLEND); - // default color - glColor4ub(255, 255, 255, 255); } @@ -344,6 +1009,55 @@ void JRenderer::RenderQuad(JQuad* quad, VertexColor* pt) BindTexture(quad->mTex); +#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) + GLfloat vVertices[] = { + pt[0].x, pt[0].y, 0.0f, + uv[0].x, uv[0].y, + pt[1].x, pt[1].y, 0.0f, + uv[1].x, uv[1].y, + pt[3].x, pt[3].y, 0.0f, + uv[3].x, uv[3].y, + pt[2].x, pt[2].y, 0.0f, + 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, + }; + + // Use the program object + glUseProgram ( prog2 ); + + // Load the vertex position + glVertexAttribPointer ( prog2_positionLoc, 3, GL_FLOAT, + GL_FALSE, 5 * sizeof(GLfloat), vVertices ); + // Load the texture coordinate + glVertexAttribPointer ( prog2_texCoordLoc, 2, GL_FLOAT, + GL_FALSE, 5 * sizeof(GLfloat), &vVertices[3] ); + // Load the colors + glVertexAttribPointer ( prog2_colorLoc, 4, GL_UNSIGNED_BYTE, + GL_TRUE, 4 * sizeof(GLubyte), colorCoords ); + + glEnableVertexAttribArray ( prog2_positionLoc ); + glEnableVertexAttribArray ( prog2_texCoordLoc ); + glEnableVertexAttribArray ( prog2_colorLoc ); + + // Load the MVP matrix + glUniformMatrix4fv( prog2_mvpLoc, 1, GL_FALSE, (GLfloat*) &theMvpMatrix.m[0][0] ); + + // Bind the texture + glActiveTexture ( GL_TEXTURE0 ); + glBindTexture ( GL_TEXTURE_2D, mCurrentTex ); + + // Set the sampler texture unit to 0 + glUniform1i ( prog2_samplerLoc, 0 ); + + //glDrawElements ( GL_TRIANGLE_STRIP, 6, GL_UNSIGNED_SHORT, indices ); + glDrawArrays(GL_TRIANGLE_STRIP,0,4); +#else glRasterPos2f(pt[0].x, pt[0].y); //float w = quad->mWidth; @@ -366,11 +1080,12 @@ void JRenderer::RenderQuad(JQuad* quad, VertexColor* pt) glColor4ub(quad->mColor[3].r, quad->mColor[3].g, quad->mColor[3].b, quad->mColor[3].a); glTexCoord2f(uv[3].x, uv[3].y); glVertex2f(pt[3].x, pt[3].y); glEnd(); + // default color + glColor4ub(255, 255, 255, 255); +#endif //(defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) //glDisable(GL_BLEND); - // default color - glColor4ub(255, 255, 255, 255); } @@ -382,7 +1097,41 @@ void JRenderer::FillRect(float x, float y, float width, float height, PIXEL_TYPE col.color = color; glDisable(GL_TEXTURE_2D); - glColor4ub(col.r, col.g, col.b, col.a); +#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) + GLfloat vVertices[] = { + x, y+height, 0.0f, + x, y, 0.0f, + x+width, y+height, 0.0f, + x+width, y, 0.0f, + }; + + 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, + }; + + // Use the program object without texture + glUseProgram ( prog1 ); + + // Load the vertex position + glVertexAttribPointer ( prog1_positionLoc, 3, GL_FLOAT, + GL_FALSE, 3 * sizeof(GLfloat), vVertices ); + // Load the color + glVertexAttribPointer(prog1_colorLoc, 4, GL_UNSIGNED_BYTE, + GL_TRUE, 4 * sizeof(GLubyte), colors); + + glEnableVertexAttribArray ( prog1_positionLoc ); + glEnableVertexAttribArray ( prog1_colorLoc ); + + // Load the MVP matrix + glUniformMatrix4fv( prog1_mvpLoc, 1, GL_FALSE, (GLfloat*) &theMvpMatrix.m[0][0] ); + + glDrawArrays(GL_TRIANGLE_STRIP,0,4); +#else + glColor4ub(col.r, col.g, col.b, col.a); + glBegin(GL_QUADS); // top left corner glVertex2f(x, y+height); @@ -397,11 +1146,12 @@ void JRenderer::FillRect(float x, float y, float width, float height, PIXEL_TYPE glVertex2f(x+width, y+height); glEnd(); + // default color + glColor4ub(255, 255, 255, 255); +#endif //(defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) glEnable(GL_TEXTURE_2D); - // default color - glColor4ub(255, 255, 255, 255); } @@ -413,8 +1163,41 @@ void JRenderer::DrawRect(float x, float y, float width, float height, PIXEL_TYPE col.color = color; glDisable(GL_TEXTURE_2D); - glColor4ub(col.r, col.g, col.b, col.a); - glBegin(GL_LINES); +#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) + GLfloat vVertices[] = { + x, y, 0.0f, + x, y+height, 0.0f, + x+width, y+height, 0.0f, + x+width, y, 0.0f, + }; + + 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, + }; + + // Use the program object without texture + glUseProgram ( prog1 ); + + // Load the vertex position + glVertexAttribPointer ( prog1_positionLoc, 3, GL_FLOAT, + GL_FALSE, 3 * sizeof(GLfloat), vVertices ); + // Load the color + glVertexAttribPointer(prog1_colorLoc, 4, GL_UNSIGNED_BYTE, + GL_TRUE, 4 * sizeof(GLubyte), colors); + + glEnableVertexAttribArray ( prog1_positionLoc ); + glEnableVertexAttribArray ( prog1_colorLoc ); + + // Load the MVP matrix + glUniformMatrix4fv( prog1_mvpLoc, 1, GL_FALSE, (GLfloat*) &theMvpMatrix.m[0][0] ); + + glDrawArrays(GL_LINE_LOOP,0,4); +#else + glColor4ub(col.r, col.g, col.b, col.a); + glBegin(GL_LINES); glVertex2f(x, y); glVertex2f(x, y+height); @@ -430,10 +1213,11 @@ void JRenderer::DrawRect(float x, float y, float width, float height, PIXEL_TYPE glEnd(); - glEnable(GL_TEXTURE_2D); + // default color + glColor4ub(255, 255, 255, 255); +#endif //#if (!defined GL_ES_VERSION_2_0) && (!defined GL_VERSION_2_0) - // default color - glColor4ub(255, 255, 255, 255); + glEnable(GL_TEXTURE_2D); } @@ -452,7 +1236,41 @@ void JRenderer::FillRect(float x, float y, float width, float height, JColor* co y = SCREEN_HEIGHT_F - y - height; glDisable(GL_TEXTURE_2D); - glBegin(GL_QUADS); + +#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) + GLfloat vVertices[] = { + x, y+height, 0.0f, + x, y, 0.0f, + x+width, y+height, 0.0f, + x+width, y, 0.0f, + }; + + 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, + }; + + // Use the program object without texture + glUseProgram ( prog1 ); + + // Load the vertex position + glVertexAttribPointer ( prog1_positionLoc, 3, GL_FLOAT, + GL_FALSE, 3 * sizeof(GLfloat), vVertices ); + // Load the color + glVertexAttribPointer(prog1_colorLoc, 4, GL_UNSIGNED_BYTE, + GL_TRUE, 4 * sizeof(GLubyte), cols); + + glEnableVertexAttribArray ( prog1_positionLoc ); + glEnableVertexAttribArray ( prog1_colorLoc ); + + // Load the MVP matrix + glUniformMatrix4fv( prog1_mvpLoc, 1, GL_FALSE, (GLfloat*) &theMvpMatrix.m[0][0] ); + + glDrawArrays(GL_TRIANGLE_STRIP,0,4); +#else + glBegin(GL_QUADS); // top left corner glColor4ub(colors[0].r, colors[0].g, colors[0].b, colors[0].a); glVertex2f(x, y+height); @@ -471,12 +1289,12 @@ void JRenderer::FillRect(float x, float y, float width, float height, JColor* co glEnd(); + // default color + glColor4ub(255, 255, 255, 255); +#endif //#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) + glEnable(GL_TEXTURE_2D); - //glDisable(GL_BLEND); - - // default color - glColor4ub(255, 255, 255, 255); } @@ -486,13 +1304,43 @@ void JRenderer::DrawLine(float x1, float y1, float x2, float y2, PIXEL_TYPE colo glDisable(GL_TEXTURE_2D); JColor col; col.color = color; - glColor4ub(col.r, col.g, col.b, col.a); - glBegin(GL_LINES); +#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) + 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, + }; + + // Use the program object without texture + glUseProgram ( prog1 ); + + // Load the vertex position + glVertexAttribPointer ( prog1_positionLoc, 3, GL_FLOAT, + GL_FALSE, 3 * sizeof(GLfloat), vVertices ); + // Load the color + glVertexAttribPointer(prog1_colorLoc, 4, GL_UNSIGNED_BYTE, + GL_TRUE, 4 * sizeof(GLubyte), cols); + + glEnableVertexAttribArray ( prog1_positionLoc ); + glEnableVertexAttribArray ( prog1_colorLoc ); + + // Load the MVP matrix + glUniformMatrix4fv( prog1_mvpLoc, 1, GL_FALSE, (GLfloat*) &theMvpMatrix.m[0][0] ); + + glDrawArrays(GL_LINES,0,2); +#else + glColor4ub(col.r, col.g, col.b, col.a); + glBegin(GL_LINES); glVertex2f(x1, SCREEN_HEIGHT_F-y1); glVertex2f(x2, SCREEN_HEIGHT_F-y2); glEnd(); - glEnable(GL_TEXTURE_2D); - glColor4ub(255, 255, 255, 255); + glColor4ub(255, 255, 255, 255); +#endif //#if (!defined GL_ES_VERSION_2_0) && (!defined GL_VERSION_2_0) + glEnable(GL_TEXTURE_2D); } @@ -501,27 +1349,35 @@ void JRenderer::Plot(float x, float y, PIXEL_TYPE color) glDisable(GL_TEXTURE_2D); JColor col; col.color = color; - glColor4ub(col.r, col.g, col.b, col.a); - glBegin(GL_POINTS); +#if (!defined GL_ES_VERSION_2_0) && (!defined GL_VERSION_2_0) + glColor4ub(col.r, col.g, col.b, col.a); + glBegin(GL_POINTS); glVertex2f(x, SCREEN_HEIGHT_F-y); glEnd(); - glEnable(GL_TEXTURE_2D); - glColor4ub(255, 255, 255, 255); + glColor4ub(255, 255, 255, 255); +#else + // FIXME, not used +#endif //#if (!defined GL_ES_VERSION_2_0) && (!defined GL_VERSION_2_0) + glEnable(GL_TEXTURE_2D); } void JRenderer::PlotArray(float *x, float *y, int count, PIXEL_TYPE color) { glDisable(GL_TEXTURE_2D); - JColor col; + JColor col; col.color = color; - glColor4ub(col.r, col.g, col.b, col.a); - glBegin(GL_POINTS); +#if (!defined GL_ES_VERSION_2_0) && (!defined GL_VERSION_2_0) + glColor4ub(col.r, col.g, col.b, col.a); + glBegin(GL_POINTS); for (int i=0;imTexId = texid; + GLenum glError = glGetError(); - if (texid != 0) + if (/*texid*/ glError == 0) { // OpenGL texture has (0,0) at lower-left // Pay attention when doing texture mapping!!! - glBindTexture(GL_TEXTURE_2D, texid); // Bind To The Texture ID - + glBindTexture(GL_TEXTURE_2D, texid); // Bind To The Texture ID +/* NOT USED if (mode == TEX_TYPE_MIPMAP) // generate mipmaps { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR_MIPMAP_LINEAR); - gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, textureInfo.mTexWidth, textureInfo.mTexHeight, GL_RGBA, GL_UNSIGNED_BYTE, textureInfo.mBits); - } + gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, textureInfo.mTexWidth, textureInfo.mTexHeight, GL_RGBA, GL_UNSIGNED_BYTE, textureInfo.mBits); + } else if (mode == TEX_TYPE_SKYBOX) // for skybox { #define GL_CLAMP_TO_EDGE 0x812F glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); - gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, textureInfo.mTexWidth, textureInfo.mTexHeight, GL_RGBA, GL_UNSIGNED_BYTE, textureInfo.mBits); - } + gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, textureInfo.mTexWidth, textureInfo.mTexHeight, GL_RGBA, GL_UNSIGNED_BYTE, textureInfo.mBits); + } else // single texture - { +*/ { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, textureInfo.mTexWidth, textureInfo.mTexHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, textureInfo.mBits); - } + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, textureInfo.mTexWidth, textureInfo.mTexHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, textureInfo.mBits); + } ret = TRUE; } + else + { + printf("TextureId is 0, GLerror is %u\n", glError); + } } @@ -1154,7 +2017,13 @@ void JRenderer::EnableVSync(bool flag __attribute__((unused))) void JRenderer::ClearScreen(PIXEL_TYPE color) { - FillRect(0.0f, 0.0f, SCREEN_WIDTH_F, SCREEN_HEIGHT_F, color); + JColor col; + col.color = color; + + glClearColor(col.r, col.g, col.b, col.a); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + +// FillRect(0.0f, 0.0f, SCREEN_WIDTH_F, SCREEN_HEIGHT_F, color); } @@ -1198,20 +2067,24 @@ void JRenderer::Enable2D() mCurrentRenderMode = MODE_2D; glViewport (0, 0, (GLsizei)SCREEN_WIDTH, (GLsizei)SCREEN_HEIGHT); // Reset The Current Viewport - glMatrixMode (GL_PROJECTION); // Select The Projection Matrix +#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, SCREEN_WIDTH_F, 0.0f, SCREEN_HEIGHT_F-1.0f); glMatrixMode (GL_MODELVIEW); // Select The Modelview Matrix glLoadIdentity (); // Reset The Modelview Matrix +#else + // all the matrix code is in shaders calls +#endif //(!defined GL_ES_VERSION_2_0) && (!defined GL_VERSION_2_0) glDisable (GL_DEPTH_TEST); } void JRenderer::Enable3D() -{ +{ /* NOT USED if (!m3DEnabled) return; @@ -1228,65 +2101,99 @@ void JRenderer::Enable3D() glMatrixMode (GL_MODELVIEW); // Select The Modelview Matrix glLoadIdentity (); // Reset The Modelview Matrix - glEnable (GL_DEPTH_TEST); + glEnable (GL_DEPTH_TEST); */ } void JRenderer::SetClip(int x, int y, int width, int height) -{ - glScissor(x, y, width, height); +{// NOT USED + //glScissor(x, y, width, height); } void JRenderer::LoadIdentity() -{ - glLoadIdentity(); +{// NOT USED + //glLoadIdentity(); } void JRenderer::Translate(float x, float y, float z) -{ - glTranslatef(x, y, z); +{// NOT USED + //glTranslatef(x, y, z); } void JRenderer::RotateX(float angle) -{ - glRotatef(angle*RAD2DEG, 1.0f, 0.0f, 0.0f); +{// NOT USED + //glRotatef(angle*RAD2DEG, 1.0f, 0.0f, 0.0f); } void JRenderer::RotateY(float angle) -{ - glRotatef(angle*RAD2DEG, 0.0f, 1.0f, 0.0f); +{// NOT USED + //glRotatef(angle*RAD2DEG, 0.0f, 1.0f, 0.0f); } void JRenderer::RotateZ(float angle) -{ - glRotatef(angle*RAD2DEG, 0.0f, 0.0f, 1.0f); +{// NOT USED + //glRotatef(angle*RAD2DEG, 0.0f, 0.0f, 1.0f); } void JRenderer::PushMatrix() -{ - glPushMatrix(); +{// NOT USED + //glPushMatrix(); } void JRenderer::PopMatrix() -{ - glPopMatrix(); +{// NOT USED + //glPopMatrix(); } - void JRenderer::RenderTriangles(JTexture* texture, Vertex3D *vertices, int start, int count) { if (texture) BindTexture(texture); - glBegin(GL_TRIANGLES); - int index = start*3; + int index = start*3; +#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) + GLubyte* colorCoords = new GLubyte[count*3*4]; + memset(colorCoords, 255, count*3*4); + + // Use the program object + glUseProgram ( prog2 ); + + // Load the vertex position + glVertexAttribPointer ( prog2_positionLoc, 3, GL_FLOAT, + GL_FALSE, 5 * sizeof(GLfloat), &vertices[index].x ); + // Load the texture coordinate + glVertexAttribPointer ( prog2_texCoordLoc, 2, GL_FLOAT, + GL_FALSE, 5 * sizeof(GLfloat), &vertices[index].u ); + // Load the colors + glVertexAttribPointer ( prog2_colorLoc, 4, GL_UNSIGNED_BYTE, + GL_TRUE, 4 * sizeof(GLubyte), colorCoords ); + + glEnableVertexAttribArray ( prog2_positionLoc ); + glEnableVertexAttribArray ( prog2_texCoordLoc ); + glEnableVertexAttribArray ( prog2_colorLoc ); + + // Load the MVP matrix + glUniformMatrix4fv( prog2_mvpLoc, 1, GL_FALSE, (GLfloat*) &theMvpMatrix.m[0][0] ); + + // Bind the texture + glActiveTexture ( GL_TEXTURE0 ); + glBindTexture ( GL_TEXTURE_2D, mCurrentTex ); + + // Set the sampler texture unit to 0 + glUniform1i ( prog2_samplerLoc, 0 ); + + glDrawArrays(GL_TRIANGLES,0,count*3); + + delete[] colorCoords; +#else + glBegin(GL_TRIANGLES); for (int i = 0; i < count; i++) { glTexCoord2f(vertices[index].u, vertices[index].v); @@ -1306,10 +2213,9 @@ void JRenderer::RenderTriangles(JTexture* texture, Vertex3D *vertices, int start glVertex3f(vertices[index].x, vertices[index].y, vertices[index].z); index++; - } glEnd(); - +#endif //#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) } @@ -1325,20 +2231,62 @@ void JRenderer::FillPolygon(float* x, float* y, int count, PIXEL_TYPE color) col.color = color; glDisable(GL_TEXTURE_2D); - glColor4ub(col.r, col.g, col.b, col.a); - glBegin(GL_TRIANGLE_FAN); +#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]; + + 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; + } + + // Use the program object without texture + glUseProgram ( prog1 ); + + // Load the vertex position + glVertexAttribPointer ( prog1_positionLoc, 3, GL_FLOAT, + GL_FALSE, 3 * sizeof(GLfloat), vVertices ); + // Load the color + glVertexAttribPointer(prog1_colorLoc, 4, GL_UNSIGNED_BYTE, + GL_TRUE, 4 * sizeof(GLubyte), colors); + + glEnableVertexAttribArray ( prog1_positionLoc ); + glEnableVertexAttribArray ( prog1_colorLoc ); + + // Load the MVP matrix + glUniformMatrix4fv( prog1_mvpLoc, 1, GL_FALSE, (GLfloat*) &theMvpMatrix.m[0][0] ); + + glDrawArrays(GL_TRIANGLE_FAN,0,count); + + delete[] vVertices; + delete[] colors; + +#else + glColor4ub(col.r, col.g, col.b, col.a); + glBegin(GL_TRIANGLE_FAN); for(int i=0; i= 360.0f) + angle -= 360.0f; + } + + // Use the program object without texture + glUseProgram ( prog1 ); + + // Load the vertex position + glVertexAttribPointer ( prog1_positionLoc, 3, GL_FLOAT, + GL_FALSE, 3 * sizeof(GLfloat), vVertices ); + // Load the color + glVertexAttribPointer(prog1_colorLoc, 4, GL_UNSIGNED_BYTE, + GL_TRUE, 4 * sizeof(GLubyte), colors); + + glEnableVertexAttribArray ( prog1_positionLoc ); + glEnableVertexAttribArray ( prog1_colorLoc ); + + // Load the MVP matrix + glUniformMatrix4fv( prog1_mvpLoc, 1, GL_FALSE, (GLfloat*) &theMvpMatrix.m[0][0] ); + + glDrawArrays(GL_LINE_LOOP,0,count); + + delete[] vVertices; + delete[] colors; +#else + 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; + + // Use the program object without texture + glUseProgram ( prog1 ); + + // Load the vertex position + glVertexAttribPointer ( prog1_positionLoc, 3, GL_FLOAT, + GL_FALSE, 3 * sizeof(GLfloat), vVertices ); + // Load the color + glVertexAttribPointer(prog1_colorLoc, 4, GL_UNSIGNED_BYTE, + GL_TRUE, 4 * sizeof(GLubyte), colors); + + glEnableVertexAttribArray ( prog1_positionLoc ); + glEnableVertexAttribArray ( prog1_colorLoc ); + + // Load the MVP matrix + glUniformMatrix4fv( prog1_mvpLoc, 1, GL_FALSE, (GLfloat*) &theMvpMatrix.m[0][0] ); + + glDrawArrays(GL_TRIANGLE_FAN,0,count+2); + + delete[] vVertices; + delete[] colors; +#else + glColor4ub(col.r, col.g, col.b, col.a); + glBegin(GL_TRIANGLE_FAN); glVertex2f(x, SCREEN_HEIGHT_F-y); @@ -1503,13 +2687,13 @@ void JRenderer::FillPolygon(float x, float y, float size, int count, float start glVertex2f(x+size*COSF((int)firstAngle), SCREEN_HEIGHT_F-y+size*SINF((int)firstAngle)); - glEnd(); - glEnable(GL_TEXTURE_2D); + // default color + glColor4ub(255, 255, 255, 255); +#endif //#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) - // default color - glColor4ub(255, 255, 255, 255); + glEnable(GL_TEXTURE_2D); } @@ -1528,8 +2712,100 @@ void JRenderer::DrawRoundRect(float x, float y, float w, float h, float radius, col.color = color; glDisable(GL_TEXTURE_2D); - glColor4ub(col.r, col.g, col.b, col.a); - glBegin(GL_LINE_LOOP); +#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) + int i, index = 1; + int number = 360+2*h+2*w; + GLfloat* vVertices = new GLfloat[3*number]; + GLubyte* colors = new GLubyte[4*number]; + + for(i = 0; i < number; 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; + } + + index = 0; + for(i=0; i<90;i++) { + vVertices[3*(index+i)+0] = x+radius*COSF(i); + vVertices[3*(index+i)+1] = SCREEN_HEIGHT_F-y+radius*SINF(i); + vVertices[3*(index+i)+2] = 0.0f; + } + index += 90; + for(i=0; iStopMusic(this); if (mTrack) FSOUND_Sample_Free(mTrack); #endif +#endif } +#ifdef USE_PHONON +void JMusic::seekAtTheBegining() +{ + mMediaObject->seek(0); +} +#endif ////////////////////////////////////////////////////////////////////////// JSample::JSample() +#ifdef USE_PHONON + : mOutput(0), mMediaObject(0) +#endif { } JSample::~JSample() { +#ifdef USE_PHONON + if(mOutput) + delete mOutput; + if(mMediaObject) + delete mMediaObject; +#else #ifdef WITH_FMOD if (mSample) FSOUND_Sample_Free(mSample); #endif +#endif } unsigned long JSample::fileSize() @@ -96,7 +121,9 @@ JSoundSystem::JSoundSystem() { mVolume = 0; mSampleVolume = 0; +#ifdef WITH_FMOD mChannel = FSOUND_FREE; +#endif } JSoundSystem::~JSoundSystem() @@ -121,6 +148,18 @@ void JSoundSystem::DestroySoundSystem() JMusic *JSoundSystem::LoadMusic(const char *fileName) { +#ifdef USE_PHONON + JMusic* music = new JMusic(); + if (music) + { + music->mOutput = new Phonon::AudioOutput(Phonon::GameCategory, 0); + music->mMediaObject = new Phonon::MediaObject(0); + music->mMediaObject->setCurrentSource("Res/" + QString(fileName)); + Phonon::Path path = Phonon::createPath(music->mMediaObject, music->mOutput); + Q_ASSERT(path.isValid()); + } + return music; +#else #ifndef WITH_FMOD return NULL; #else @@ -141,11 +180,24 @@ JMusic *JSoundSystem::LoadMusic(const char *fileName) } return music; #endif +#endif } void JSoundSystem::PlayMusic(JMusic *music, bool looping) { +#ifdef USE_PHONON + if (music && music->mMediaObject && music->mOutput) + { + if(looping) + { + music->mMediaObject->connect(music->mMediaObject, SIGNAL(aboutToFinish()), music, SLOT(seekAtTheBegining())); + } + music->mOutput->setVolume((qreal)mVolume*0.01); + music->mMediaObject->play(); + + } +#else #ifdef WITH_FMOD if (music && music->mTrack) { @@ -158,14 +210,22 @@ void JSoundSystem::PlayMusic(JMusic *music, bool looping) FSOUND_SetLoopMode(mChannel, FSOUND_LOOP_OFF); } #endif +#endif } void JSoundSystem::StopMusic(JMusic *music) { +#ifdef USE_PHONON + if (music && music->mMediaObject && music->mOutput) + { + music->mMediaObject->stop(); + } +#else #ifdef WITH_FMOD FSOUND_StopSound(mChannel); #endif +#endif } @@ -195,6 +255,18 @@ void JSoundSystem::SetSfxVolume(int volume){ JSample *JSoundSystem::LoadSample(const char *fileName) { +#ifdef USE_PHONON + JSample* sample = new JSample(); + if (sample) + { + sample->mOutput = new Phonon::AudioOutput(Phonon::GameCategory, 0); + sample->mMediaObject = new Phonon::MediaObject(0); + sample->mMediaObject->setCurrentSource("Res/" + QString(fileName)); + Phonon::Path path = Phonon::createPath(sample->mMediaObject, sample->mOutput); + Q_ASSERT(path.isValid()); + } + return sample; +#else #ifndef WITH_FMOD return NULL; #else @@ -217,16 +289,25 @@ JSample *JSoundSystem::LoadSample(const char *fileName) } return sample; #endif +#endif } void JSoundSystem::PlaySample(JSample *sample) { +#ifdef USE_PHONON + if (sample && sample->mMediaObject && sample->mOutput) + { + sample->mOutput->setVolume((qreal)mSampleVolume*0.01); + sample->mMediaObject->play(); + } +#else #ifdef WITH_FMOD if (sample && sample->mSample){ int channel = FSOUND_PlaySound(FSOUND_FREE, sample->mSample); FSOUND_SetVolumeAbsolute(channel,mSampleVolume * 2.55); } #endif +#endif } diff --git a/projects/mtg/include/MTGPack.h b/projects/mtg/include/MTGPack.h index d023e94c0..9f22313db 100644 --- a/projects/mtg/include/MTGPack.h +++ b/projects/mtg/include/MTGPack.h @@ -69,7 +69,7 @@ protected: int price; //Base price. int minCards, maxCards; - vector slots; + vector slotss; }; class MTGPacks{ diff --git a/projects/mtg/include/config.h b/projects/mtg/include/config.h index fdcd5b8cc..362f5b1dd 100644 --- a/projects/mtg/include/config.h +++ b/projects/mtg/include/config.h @@ -23,6 +23,10 @@ #define NEW new #endif +#ifdef QT_CONFIG +#include +#define OutputDebugString(val) qDebug(val) +#else #ifdef LINUX #ifdef _DEBUG #define OutputDebugString(val) (std::cerr << val); @@ -30,6 +34,8 @@ #define OutputDebugString(val) {} #endif #endif +#endif + #ifndef RESPATH #define RESPATH "Res" diff --git a/projects/mtg/src/GameStateShop.cpp b/projects/mtg/src/GameStateShop.cpp index d852845bc..ef22e46d3 100644 --- a/projects/mtg/src/GameStateShop.cpp +++ b/projects/mtg/src/GameStateShop.cpp @@ -819,12 +819,15 @@ bool ShopBooster::unitTest(){ u+=ddw->count(c); card++; } + int count = ddw->getCount(); + SAFE_DELETE(ddw); + SAFE_DELETE(d); if(r != 1 || u != 3 ){ sprintf(result, "==Unexpected rarity count==
"); TestSuite::Log(result); res = false; } - if(ddw->getCount() < 14) { + if(count < 14) { sprintf(result, "==Unexpected card count==
"); TestSuite::Log(result); res = false; diff --git a/projects/mtg/src/MTGAbility.cpp b/projects/mtg/src/MTGAbility.cpp index e5375c158..9f21cb2f3 100644 --- a/projects/mtg/src/MTGAbility.cpp +++ b/projects/mtg/src/MTGAbility.cpp @@ -1095,16 +1095,21 @@ MTGAbility * AbilityFactory::parseMagicLine(string s, int id, Spell * spell, MTG ab = NEW ABecomes(id,card,target,stypes,pt,sabilities); }return ab; } + //bloodthirst found = s.find("bloodthirst:"); if (found != string::npos){ size_t start = s.find(":",found); size_t end = s.find(" ",start); int amount; - if (end != string::npos){amount = atoi(s.substr(start+1,end-start-1).c_str());} - else{amount = atoi(s.substr(start+1).c_str());} + if (end != string::npos){ + amount = atoi(s.substr(start+1,end-start-1).c_str()); + } else { + amount = atoi(s.substr(start+1).c_str()); + } MTGAbility * a = NEW ABloodThirst(id,card,target,amount); - return a;} + return a; + } diff --git a/projects/mtg/src/MTGPack.cpp b/projects/mtg/src/MTGPack.cpp index 06b47ace2..f343597b2 100644 --- a/projects/mtg/src/MTGPack.cpp +++ b/projects/mtg/src/MTGPack.cpp @@ -93,8 +93,8 @@ int MTGPack::assemblePack(MTGDeck *to){ if(!p) return -1; p->Shuffle(); - for(size_t i=0;iadd(p,to,carryover); + for(size_t i=0;iadd(p,to,carryover); if(carryover > 0) carryover = carryover; //This means we're failing. } @@ -104,8 +104,8 @@ int MTGPack::assemblePack(MTGDeck *to){ void MTGPack::countCards(){ minCards = 0; maxCards = 0; - for(size_t i=0;ientries.size();y++){ @@ -160,7 +160,7 @@ void MTGPack::load(string filename){ std::transform(tag.begin(),tag.end(),tag.begin(),::tolower); if(tag != "slot") continue; MTGPackSlot * s = NEW MTGPackSlot(); - slots.push_back(s); + slotss.push_back(s); holder = pSlot->Attribute("copies"); if(holder) s->copies = atoi(holder); else s->copies = 1; @@ -202,10 +202,10 @@ MTGPackSlot::~MTGPackSlot(){ entries.clear(); } MTGPack::~MTGPack(){ - for(size_t t=0;taddEntry(NEW MTGPackEntryRandom("rarity:mythic;")); for(int i=0;i<7;i++) ps->addEntry(NEW MTGPackEntryRandom("rarity:rare;")); - defaultBooster.slots.push_back(ps); + defaultBooster.slotss.push_back(ps); ps = NEW MTGPackSlot(); ps->copies = 3; ps->addEntry(NEW MTGPackEntryRandom("rarity:uncommon;")); - defaultBooster.slots.push_back(ps); + defaultBooster.slotss.push_back(ps); ps = NEW MTGPackSlot(); ps->copies = 1; ps->addEntry(NEW MTGPackEntryRandom("rarity:land;&type:basic;")); - defaultBooster.slots.push_back(ps); + defaultBooster.slotss.push_back(ps); ps = NEW MTGPackSlot(); ps->copies = 10; ps->addEntry(NEW MTGPackEntryRandom("rarity:common;")); - defaultBooster.slots.push_back(ps); + defaultBooster.slotss.push_back(ps); defaultBooster.bValid = true; defaultBooster.unlockStatus = 1; } diff --git a/projects/mtg/wagic.pro b/projects/mtg/wagic.pro new file mode 100644 index 000000000..b6f481639 --- /dev/null +++ b/projects/mtg/wagic.pro @@ -0,0 +1,321 @@ +#------------------------------------------------- +# +# Project created by QtCreator 2010-06-30T19:48:30 +# +#------------------------------------------------- + +QT += core gui opengl +VERSION = 1.2.3 +TARGET = wagic +TEMPLATE = app +windows:DEFINES += WIN32 +windows:DEFINES += _CRT_SECURE_NO_WARNINGS +windows:DEFINES += FORCE_GL2 +unix:DEFINES += LINUX +DEFINES += QT_CONFIG +maemo5 { +DEFINES += USE_PHONON +QT += phonon +} +windows:INCLUDEPATH += ../../JGE/Dependencies/include +unix:INCLUDEPATH += /usr/include/GL +unix:INCLUDEPATH += /usr/include/freetype2 +INCLUDEPATH += ../../JGE/include +INCLUDEPATH += include + +unix:LIBS += -ljpeg -lgif -lpng12 +windows:LIBS += -LD:\Projects\Wagic\JGE\Dependencies\lib -llibjpeg-static-mt-debug -lgiflib -llibpng -lfmodvc + +# MGT +SOURCES += \ + src/ActionElement.cpp\ + src/ActionLayer.cpp\ + src/ActionStack.cpp\ + src/AIMomirPlayer.cpp\ + src/AIPlayer.cpp\ + src/AIStats.cpp\ + src/CardDescriptor.cpp\ + src/CardDisplay.cpp\ + src/CardEffect.cpp\ + src/CardGui.cpp\ + src/CardPrimitive.cpp\ + src/CardSelector.cpp\ + src/Closest.cpp\ + src/Counters.cpp\ + src/Credits.cpp\ + src/Damage.cpp\ + src/DamagerDamaged.cpp\ + src/DeckDataWrapper.cpp\ + src/DeckMetaData.cpp\ + src/DeckManager.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/Logger.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/OptionItem.cpp\ + src/PhaseRing.cpp\ + src/Player.cpp\ + src/PlayerData.cpp\ + src/PlayGuiObject.cpp\ + src/PlayGuiObjectController.cpp\ + src/Pos.cpp\ + src/PriceList.cpp\ + src/ReplacementEffects.cpp\ + src/Rules.cpp\ + src/SimpleMenu.cpp\ + src/SimpleMenuItem.cpp\ + src/SimplePad.cpp\ + src/StoryFlow.cpp\ + src/Subtypes.cpp\ + src/StyleManager.cpp\ + src/TargetChooser.cpp\ + src/TargetsList.cpp\ + src/Tasks.cpp\ + src/TestSuiteAI.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 + +HEADERS += \ + 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/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/ShopItem.h\ + include/Effects.h\ + include/Logger.h\ + include/StyleManager.h\ + include/WFont.h\ + include/DeckManager.h\ + include/SimpleMenu.h + +# JGE, could probably be moved outside +SOURCES += \ + ../../JGE/src/Qtmain.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/JGBKFont.cpp\ + ../../JGE/src/JGE.cpp\ + ../../JGE/src/JGui.cpp\ + ../../JGE/src/JLBFont.cpp\ + ../../JGE/src/JLogger.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/JTTFont.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 + +HEADERS += \ + ../../JGE/include/decoder_prx.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/JGBKFont.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/JTTFont.h\ + ../../JGE/include/JTypes.h\ + ../../JGE/include/Vector2D.h\ + ../../JGE/include/Vector3D.h\ + ../../JGE/include/vram.h\ + ../../JGE/src/tinyxml\tinystr.h\ + ../../JGE/src/tinyxml\tinyxml.h\ + ../../JGE/include/vram.h + +FORMS += + +CONFIG += mobility +MOBILITY = + +symbian { + TARGET.UID3 = 0xe3fa5a9c + # TARGET.CAPABILITY += + TARGET.EPOCSTACKSIZE = 0x14000 + TARGET.EPOCHEAPSIZE = 0x020000 0x800000 +} + +OTHER_FILES += + +RESOURCES +=