├── .gitmodules
├── .gitignore
├── haiku
    ├── main.cpp
    ├── app.hpp
    ├── app.cpp
    ├── tmxgl.hpp
    ├── window.hpp
    ├── AZPAZETATMX.rdef
    ├── window.cpp
    └── tmxgl.cpp
├── lib
    ├── gl.hpp
    ├── XML.cpp
    └── gl.cpp
├── qt
    ├── window.hpp
    ├── glwidget.hpp
    ├── main.cpp
    ├── window.cpp
    └── glwidget.cpp
├── README.md
├── fltk
    └── main.cpp
├── LICENSE
├── sdl
    └── main.cpp
├── x11
    └── main.cpp
└── CMakeLists.txt


/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "tinyxml2"]
2 | path=tinyxml2
3 | url=git://github.com/leethomason/tinyxml2
4 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | CMakeCache.txt
2 | CMakeFiles
3 | Makefile
4 | cmake_install.cmake
5 | build/
6 | install_manifest.txt
7 | 


--------------------------------------------------------------------------------
/haiku/main.cpp:
--------------------------------------------------------------------------------
1 | #include "app.hpp"
2 | 
3 | int main(int argc, char** argv)
4 | {
5 | 	AzpazetaTMX tmx;
6 | 	tmx.Run();
7 | 	return 0;
8 | }
9 | 


--------------------------------------------------------------------------------
/lib/gl.hpp:
--------------------------------------------------------------------------------
 1 | #include <GL/gl.h>
 2 | 
 3 | #ifndef GL_HPP
 4 | #define GL_HPP
 5 | 
 6 | void StartGL();
 7 | void RefreshGL();
 8 | void ResizeGL(int width, int height);
 9 | 
10 | #endif
11 | 


--------------------------------------------------------------------------------
/haiku/app.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef APP_HPP
 2 | #define APP_HPP
 3 | 
 4 | #include <Application.h>
 5 | 
 6 | class AzpazetaTMX : public BApplication{
 7 | public:
 8 | 	AzpazetaTMX();
 9 | 	void ReadyToRun();	
10 | };
11 | 
12 | #endif
13 | 


--------------------------------------------------------------------------------
/haiku/app.cpp:
--------------------------------------------------------------------------------
 1 | #include "app.hpp"
 2 | #include "window.hpp"
 3 | 
 4 | AzpazetaTMX::AzpazetaTMX() : BApplication("application/azpazeta-tmx")
 5 | {
 6 | 	
 7 | }
 8 | void AzpazetaTMX::ReadyToRun()
 9 | {
10 | 	BWindow* win=new Window();
11 | 	win->Show();
12 | }
13 | 


--------------------------------------------------------------------------------
/haiku/tmxgl.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef TMXGL_HPP
 2 | #define TMXGL_HPP
 3 | 
 4 | class TMXGL : public BGLView {
 5 | public:
 6 | 	TMXGL();
 7 | 	virtual void AttachedToWindow();
 8 | 	virtual void FrameResized(float width, float height);
 9 | 	virtual void ErrorCallback(GLenum which);
10 | 	
11 | 	void Render();	
12 | };
13 | 
14 | #endif
15 | 


--------------------------------------------------------------------------------
/haiku/window.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef WINDOW_HPP
 2 | #define WINDOW_HPP
 3 | 
 4 | #include <Window.h>
 5 | #include <opengl/GLView.h>
 6 | #include "tmxgl.hpp"
 7 | 
 8 | class Window : public BWindow{
 9 | public:
10 | 	Window();
11 | 	bool QuitRequested();
12 | 	void MessageReceived(BMessage* msg);
13 | private:
14 | 	TMXGL* gl;	
15 | };
16 | #endif WINDOW_HPP
17 | 


--------------------------------------------------------------------------------
/qt/window.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef WINDOW_H
 2 | #define WINDOW_H
 3 | 
 4 | #include <QWidget>
 5 | 
 6 | class QSlider;
 7 | 
 8 | class GLWidget;
 9 | 
10 | class Window : public QWidget
11 | {
12 | 
13 | public:
14 |     Window();
15 | 
16 | protected:
17 |     void keyPressEvent(QKeyEvent *event);
18 | 
19 | private:
20 |     GLWidget *glWidget;
21 | };
22 | 
23 | #endif
24 | 


--------------------------------------------------------------------------------
/qt/glwidget.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef GLWIDGET_H
 2 | #define GLWIDGET_H
 3 | 
 4 | #include <QGLWidget>
 5 | 
 6 | class GLWidget : public QGLWidget
 7 | {
 8 | 
 9 | public:
10 |     GLWidget(QWidget *parent = 0);
11 |     ~GLWidget();
12 | 
13 |     QSize minimumSizeHint() const;
14 |     QSize sizeHint() const;
15 | 
16 | protected:
17 |     void initializeGL();
18 |     void paintGL();
19 |     void resizeGL(int width, int height);
20 | };
21 | 
22 | #endif
23 | 


--------------------------------------------------------------------------------
/lib/XML.cpp:
--------------------------------------------------------------------------------
 1 | /* Starts reading the XML file */
 2 | 
 3 | #include "../tinyxml2/tinyxml2.h"
 4 | 
 5 | #include <iostream>
 6 | 
 7 | typedef struct {
 8 | 	TiXmlProperties *properties, *property, *tileset, *layer, *data, *tile;
 9 | } AzpazetaTMX;
10 | 
11 | XML::XML(std::string file)
12 | {
13 | 	TiXmlDocument doc(file);
14 | 	if(!doc.LoadFile())
15 | 	{
16 | 		std::cerr << "ERROR LOADING FILE" << std::endl;	
17 | 	}
18 | 	TiXmlProperties *property;
19 | }
20 | XML::~XML()
21 | {
22 | 	
23 | }
24 | 


--------------------------------------------------------------------------------
/qt/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <QApplication>
 2 | #include <QDesktopWidget>
 3 | 
 4 | #include "window.hpp"
 5 | 
 6 | int main(int argc, char** argv)
 7 | {
 8 | 	QApplication app(argc, argv);
 9 | 	Window window;
10 | 	int desktopArea = QApplication::desktop()->width() * QApplication::desktop()->height();
11 | 	int widgetArea = window.width() * window.height();
12 | 	if(((float)widgetArea / (float)desktopArea) < 0.75f)
13 | 		window.show();
14 | 	else
15 | 		window.showMaximized();
16 | 	return app.exec();
17 | }
18 | 


--------------------------------------------------------------------------------
/haiku/AZPAZETATMX.rdef:
--------------------------------------------------------------------------------
 1 | resource app_signature "application/azpazeta-tmx";
 2 | 
 3 | resource app_flags B_SINGLE_LAUNCH;
 4 | 
 5 | resource app_version {
 6 | 	major = 0,
 7 | 	middle = 0,
 8 | 	minor = 1,
 9 | 	
10 | 	variety = B_APPV_DEVELOPMENT,
11 | 	internal = 1,
12 | 	
13 | 	short_info = "Azpazeta TMX Viewer",
14 | 	long_info = "See your maps for Azpazeta with this viewer"	
15 | };
16 | resource vector_icon{
17 | 	$"6E63696602030000FF03FFAA00020A043C44344C44544C4C0A043428344B4454"
18 | 	$"4430020A000100000A01010100"
19 | };
20 | 


--------------------------------------------------------------------------------
/qt/window.cpp:
--------------------------------------------------------------------------------
 1 | #include <QWidget>
 2 | #include <QHBoxLayout>
 3 | 
 4 | #include "glwidget.hpp"
 5 | #include "window.hpp"
 6 | 
 7 | Window::Window()
 8 | {
 9 |     glWidget = new GLWidget;
10 | 
11 |     QHBoxLayout *mainLayout = new QHBoxLayout;
12 |     mainLayout->addWidget(glWidget);
13 |     setLayout(mainLayout);
14 |     
15 |     setWindowTitle(tr("Azpazeta TMX Viewer"));
16 | }
17 | 
18 | void Window::keyPressEvent(QKeyEvent *e)
19 | {
20 |     /*if (e->key() == Qt::Key_Escape)
21 |         close();
22 |     else
23 |         QWidget::keyPressEvent(e);*/
24 | }
25 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Azpazeta TMX 
 2 | ============
 3 | 
 4 | Azpazeta TMX is a tool for see native TMX maps for Azpazeta without opening Azpazeta. It uses OpenGL ES 2 and uses differents backends:
 5 | * Haiku
 6 | * wxWidgets
 7 | * FLTK
 8 | * Gtk
 9 | * X11
10 | * QT
11 | * SDL
12 | * WinAPI
13 | 
14 | Azpazeta TMX uses the same implementation of TMX as Azpazeta based on TinyXML.
15 | 
16 | Building
17 | ========
18 | 
19 | First you need to configure the backends that you want to build. Something like that for SDL and QT:
20 | ```
21 | cmake . -DSDL_BACKEND=ON -DQT_BACKEND=ON
22 | 
23 | make
24 | ```
25 | 
26 | 


--------------------------------------------------------------------------------
/haiku/window.cpp:
--------------------------------------------------------------------------------
 1 | #include "window.hpp"
 2 | 
 3 | const int32_t EXIT='EXIT';
 4 | 
 5 | Window::Window() : BWindow(BRect(50,50,800,600),"Azpazeta TMX",B_TITLED_WINDOW,0)
 6 | {
 7 | 	gl=new TMXGL();
 8 | 	AddChild(gl);
 9 | }
10 | bool Window::QuitRequested()
11 | {
12 | 	be_app_messenger.SendMessage(B_QUIT_REQUESTED);
13 | 	return BWindow::QuitRequested();
14 | }
15 | void Window::MessageReceived(BMessage* msg)
16 | {
17 | 	switch(msg->what)
18 | 	{
19 | 		case EXIT : {
20 | 				QuitRequested();
21 | 				break;
22 | 			}
23 | 		default: {
24 | 			BWindow::MessageReceived(msg);
25 | 			}
26 | 	}
27 | }
28 | 


--------------------------------------------------------------------------------
/lib/gl.cpp:
--------------------------------------------------------------------------------
 1 | #include "gl.hpp"
 2 | 
 3 | void StartGL()
 4 | {
 5 | 	glClearColor(0.0f,0.0f,0.0f,0.0f);
 6 | 	glClear(GL_COLOR_BUFFER_BIT);
 7 | 	glEnable(GL_TEXTURE_2D);
 8 | }
 9 | void RefreshGL()
10 | {
11 | 	glLoadIdentity();
12 | 	//glClear(GL_COLOR_BUFFER_BIT);
13 | 	glColor4f(1, 1, 1, 1);
14 |     glBegin(GL_QUADS);
15 | 		glVertex3f(0,0,0);
16 | 		glVertex3f(50,0,0);
17 | 		glVertex3f(50,50,0);
18 | 		glVertex3f(0,50,0);
19 | 	glEnd();
20 | }
21 | void ResizeGL(int width, int height)
22 | {
23 | 	glLoadIdentity();
24 | 	//glClear(GL_COLOR_BUFFER_BIT);
25 | 	glColor4f(1, 1, 1, 1);
26 |     glBegin(GL_QUADS);
27 | 		glVertex3f(0,0,0);
28 | 		glVertex3f(width,0,0);
29 | 		glVertex3f(width,height,0);
30 | 		glVertex3f(0,height,0);
31 | 	glEnd();
32 | }
33 | 


--------------------------------------------------------------------------------
/haiku/tmxgl.cpp:
--------------------------------------------------------------------------------
 1 | #include <opengl/GLView.h>
 2 | #include "tmxgl.hpp"
 3 | #include "../lib/gl.hpp"
 4 | 
 5 | TMXGL::TMXGL() : BGLView(BRect(0,0,800,600),"Azpazeta TMX",B_FOLLOW_ALL_SIDES,0,BGL_RGB|BGL_DOUBLE)
 6 | {
 7 | 	
 8 | }
 9 | void TMXGL::AttachedToWindow()
10 | {
11 | 	LockGL();
12 | 	BGLView::AttachedToWindow();
13 | 	StartGL();
14 | 	RefreshGL();
15 | 	Render();
16 | 	UnlockGL();
17 | }
18 | void TMXGL::FrameResized(float width, float height)
19 | {
20 | 	LockGL();
21 | 	BGLView::FrameResized(width, height);
22 | 	ResizeGL((int)width,(int)height);
23 | 	UnlockGL();
24 | 	Render();
25 | }
26 | void TMXGL::ErrorCallback(GLenum which)
27 | {
28 | 	
29 | }
30 | void TMXGL::Render()
31 | {
32 | 	LockGL();
33 | 	RefreshGL();
34 | 	SwapBuffers();
35 | 	UnlockGL();
36 | }
37 | 


--------------------------------------------------------------------------------
/fltk/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <FL/Fl.H>
 2 | #include <FL/Fl_Window.H>
 3 | #include <FL/Fl_Button.H>
 4 | #include <FL/Fl_Gl_Window.H>
 5 | #include "../lib/gl.hpp"
 6 | 
 7 | class TMXWin : public Fl_Gl_Window{
 8 | 	public:
 9 | 		TMXWin(int x, int y, int w, int h, const char* l=0) : Fl_Gl_Window(x,y,w,h,l)
10 | 		{
11 | 			StartGL();
12 | 		}
13 | 		void draw()
14 | 		{
15 | 			RefreshGL();
16 | 		}
17 | 		void resize(int X, int Y,int W, int H)
18 | 		{
19 | 			Fl_Gl_Window::resize(X,Y,W,H);
20 | 			ResizeGL(W,H);
21 | 		}
22 | 	
23 | };
24 | 
25 | int main(int argc, char** argv)
26 | {
27 | 	Fl_Window win(500,500,"Azpazeta TMX Viewer");
28 | 	TMXWin window(10,10,win.w()-20,win.h()-20);
29 | 	win.end();
30 | 	win.resizable(window);
31 | 	win.show(argc,argv);
32 | 	return Fl::run();
33 | }
34 | 
35 | 
36 | 


--------------------------------------------------------------------------------
/qt/glwidget.cpp:
--------------------------------------------------------------------------------
 1 | #include <QHBoxLayout>
 2 | #include <QtOpenGL>
 3 | 
 4 | #include <math.h>
 5 | 
 6 | #include "glwidget.hpp"
 7 | 
 8 | #include "../lib/gl.hpp"
 9 | 
10 | #ifndef GL_MULTISAMPLE
11 | #define GL_MULTISAMPLE  0x809D
12 | #endif
13 | 
14 | GLWidget::GLWidget(QWidget *parent)
15 |     : QGLWidget(QGLFormat(QGL::SampleBuffers), parent)
16 | {
17 | 	
18 | }
19 | 
20 | GLWidget::~GLWidget()
21 | {
22 | }
23 | 
24 | QSize GLWidget::minimumSizeHint() const
25 | {
26 |     return QSize(50, 50);
27 | }
28 | 
29 | QSize GLWidget::sizeHint() const
30 | {
31 |     return QSize(400, 400);
32 | }
33 | 
34 | static void qNormalizeAngle(int &angle)
35 | {
36 |     while (angle < 0)
37 |         angle += 360 * 16;
38 |     while (angle > 360 * 16)
39 |         angle -= 360 * 16;
40 | }
41 | 
42 | void GLWidget::initializeGL()
43 | {
44 |     //qglClearColor(qtPurple.dark());
45 | 	StartGL();
46 | }
47 | 
48 | void GLWidget::paintGL()
49 | {
50 |     RefreshGL();
51 | }
52 | 
53 | void GLWidget::resizeGL(int width, int height)
54 | {
55 |     ResizeGL(width, height);
56 | }
57 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 Adrián Arroyo Calle
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/sdl/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <SDL/SDL.h>
 2 | #include "../lib/gl.hpp"
 3 | 
 4 | int main(int argc, char** argv)
 5 | {
 6 | 	const SDL_VideoInfo* info = NULL;
 7 | 	int width=640;
 8 | 	int height=480;
 9 | 	int bpp=0;
10 | 	int flags=0;
11 | 	if(SDL_Init(SDL_INIT_VIDEO) < 0)
12 | 	{
13 | 		SDL_Quit();
14 | 		return 1;
15 | 	}
16 | 	info=SDL_GetVideoInfo();
17 | 	if(!info)
18 | 	{
19 | 		SDL_Quit();
20 | 		return 1;
21 | 	}
22 | 	bpp = info->vfmt->BitsPerPixel;
23 | 	SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 5 );
24 |     SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 5 );
25 |     SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 5 );
26 |     SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
27 |     SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
28 |     
29 |     flags = SDL_OPENGL | SDL_RESIZABLE;
30 |     
31 |     if(SDL_SetVideoMode(width, height, bpp, flags) < 0)
32 |     {
33 | 		SDL_Quit();
34 | 		return 1;
35 | 	}
36 | 	StartGL();
37 | 	while(1)
38 | 	{
39 | 		SDL_Event event;
40 | 		while(SDL_PollEvent(&event))
41 | 		{
42 | 			switch (event.type){
43 | 				case SDL_KEYDOWN:
44 | 				SDL_Quit();
45 | 				return 0;
46 | 				break;
47 | 				case SDL_QUIT:
48 | 				SDL_Quit();
49 | 				return 0;
50 | 				break;
51 | 			}
52 | 		}
53 | 		RefreshGL();
54 | 		SDL_GL_SwapBuffers();
55 | 	}
56 | 	return 0;
57 | }
58 | 


--------------------------------------------------------------------------------
/x11/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <GL/gl.h>
 2 | #include <GL/glx.h>
 3 | #include <X11/Xlib.h>
 4 | #include <X11/Xutil.h>
 5 | #include <stdio.h>
 6 | 
 7 | #include "../lib/gl.hpp"
 8 | 
 9 | Display                 *display;
10 | Window                  root;
11 | GLint                   att[] = { GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None };
12 | XVisualInfo             *vi;
13 | Colormap                cmap;
14 | XSetWindowAttributes    swa;
15 | Window                  win;
16 | GLXContext              glc;
17 | XWindowAttributes       gwa;
18 | XEvent                  xev;
19 | 
20 | int main(int argc, char** argv)
21 | {
22 | 	display=XOpenDisplay(NULL);
23 | 	if(!display)
24 | 	{
25 | 		printf("[ERROR] Cannot open X11 display");
26 | 		return 1;
27 | 	}
28 | 	root=DefaultRootWindow(display);
29 | 	vi=glXChooseVisual(display, 0, att);
30 | 	cmap=XCreateColormap(display, root, vi->visual, AllocNone);
31 | 	swa.colormap = cmap;
32 | 	swa.event_mask = ExposureMask | KeyPressMask;
33 | 	win = XCreateWindow(display, root, 0, 0, 600, 600, 0, vi->depth, InputOutput, vi->visual, CWColormap | CWEventMask, &swa);
34 | 	XMapWindow(display, win);
35 | 	XStoreName(display, win, "Azpazeta TMX Viewer");
36 | 	glc=glXCreateContext(display,vi,NULL,GL_TRUE);
37 | 	glXMakeCurrent(display,win,glc);
38 | 	StartGL();
39 | 	while(1) {
40 |         XNextEvent(display, &xev);
41 |         
42 |         if(xev.type == Expose) {
43 |                 XGetWindowAttributes(display, win, &gwa);
44 |                 glViewport(0, 0, gwa.width, gwa.height);
45 |                 RefreshGL();
46 |                 glXSwapBuffers(display, win);
47 |         }
48 |                 
49 |         else if(xev.type == KeyPress) {
50 |                 glXMakeCurrent(display, None, NULL);
51 |                 glXDestroyContext(display, glc);
52 |                 XDestroyWindow(display, win);
53 |                 XCloseDisplay(display);
54 |                 return 0;
55 |         }
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | PROJECT(AZPAZETATMX C CXX)
 2 | CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 3 | 
 4 | SET(HAIKU_BACKEND OFF CACHE BOOL "Build Haiku backend")
 5 | SET(QT_BACKEND OFF CACHE BOOL "Build QT backend")
 6 | SET(X11_BACKEND OFF CACHE BOOL "Build X11 backend")
 7 | SET(SDL_BACKEND OFF CACHE BOOL "Build SDL backend")
 8 | SET(FLTK_BACKEND OFF CACHE BOOL "Build FLTK backend")
 9 | SET(GTK_BACKEND OFF CACHE BOOL "Build GTK backend")
10 | SET(WX_BACKEND OFF CACHE BOOL "Build wxWidgets backend")
11 | 
12 | FIND_PACKAGE(OpenGL)
13 | INCLUDE_DIRECTORIES(${OPENGL_INCLUDE_DIR})
14 | 
15 | ADD_SUBDIRECTORY(${PROJECT_SOURCE_DIR}/tinyxml2)
16 | 
17 | FILE(GLOB COMMON_SRC "${PROJECT_SOURCE_DIR}/lib/*.cpp")
18 | ADD_LIBRARY(AZPAZETATMX_GL STATIC ${COMMON_SRC})
19 | TARGET_LINK_LIBRARIES(AZPAZETATMX_GL tinyxml2static)
20 | 
21 | IF(HAIKU_BACKEND)
22 | 	FILE(GLOB HAIKU_SRC "${CMAKE_CURRENT_SOURCE_DIR}/haiku/*.cpp")
23 | 	ADD_EXECUTABLE(AZPAZETATMX_HAIKU ${HAIKU_SRC} ${COMMON_SRC})
24 | 	TARGET_LINK_LIBRARIES(AZPAZETATMX_HAIKU ${OPENGL_LIBRARIES})
25 | 	TARGET_LINK_LIBRARIES(AZPAZETATMX_HAIKU be tracker root )
26 | 	ADD_CUSTOM_COMMAND(TARGET AZPAZETATMX_HAIKU COMMAND rc -o AZPAZETATMX.rsrc ${CMAKE_CURRENT_SOURCE_DIR}/haiku/AZPAZETATMX.rdef COMMENT "Compiling resources")
27 | 	ADD_CUSTOM_COMMAND(TARGET AZPAZETATMX_HAIKU COMMAND xres -o AZPAZETATMX_HAIKU AZPAZETATMX.rsrc COMMENT "Adding resources to executable")
28 | 	ADD_CUSTOM_COMMAND(TARGET AZPAZETATMX_HAIKU COMMAND mimeset --all AZPAZETATMX_HAIKU COMMENT "Adjusting MIME types")
29 | ENDIF()
30 | 
31 | IF(QT_BACKEND)
32 | 	FIND_PACKAGE(Qt REQUIRED QtGui QtOpenGL)
33 | 	SET(QT_USE_QTOPENGL TRUE)
34 | 	include(${QT_USE_FILE})
35 | 	INCLUDE_DIRECTORIES(${QT_QTCORE_INCLUDE_DIR})
36 | 	INCLUDE_DIRECTORIES(${QT_QTGUI_INCLUDE_DIR})
37 | 	INCLUDE_DIRECTORIES(${QT_QTOPENGL_INCLUDE_DIR})
38 | 	INCLUDE_DIRECTORIES(${QT_INCLUDE_DIR})
39 | 	FILE(GLOB QT_SRC "${CMAKE_CURRENT_SOURCE_DIR}/qt/*.cpp")
40 | 	ADD_EXECUTABLE(AZPAZETATMX_QT ${QT_SRC})
41 | 	TARGET_LINK_LIBRARIES(AZPAZETATMX_QT AZPAZETATMX_GL ${OPENGL_LIBRARIES} Qt4::QtGui Qt4::QtOpenGL)
42 | ENDIF()
43 | 
44 | IF(X11_BACKEND)
45 | 	FIND_PACKAGE(X11)
46 | 	INCLUDE_DIRECTORIES(${X11_INCLUDE_DIR})
47 | 	FILE(GLOB X11_SRC "${CMAKE_CURRENT_SOURCE_DIR}/x11/*.cpp")
48 | 	ADD_EXECUTABLE(AZPAZETATMX_X11 ${X11_SRC})
49 | 	TARGET_LINK_LIBRARIES(AZPAZETATMX_X11 AZPAZETATMX_GL ${OPENGL_LIBRARIES} ${X11_LIBRARIES})
50 | ENDIF()
51 | 
52 | IF(SDL_BACKEND)
53 | 	FIND_PACKAGE(SDL)
54 | 	INCLUDE_DIRECTORIES(${SDL_INCLUDE_DIR})
55 | 	SET(SDL_BUILDING_LIBRARY TRUE)
56 | 	FILE(GLOB SDL_SRC "${CMAKE_CURRENT_SOURCE_DIR}/sdl/*.cpp")
57 | 	ADD_EXECUTABLE(AZPAZETATMX_SDL ${SDL_SRC})
58 | 	TARGET_LINK_LIBRARIES(AZPAZETATMX_SDL AZPAZETATMX_GL ${OPENGL_LIBRARIES} ${SDL_LIBRARY})
59 | ENDIF()
60 | 
61 | IF(FLTK_BACKEND)
62 | 	FIND_PACKAGE(FLTK)
63 | 	INCLUDE_DIRECTORIES(${FLTK_INCLUDE_DIR})
64 | 	FILE(GLOB FLTK_SRC "${CMAKE_CURRENT_SOURCE_DIR}/fltk/*.cpp")
65 | 	ADD_EXECUTABLE(AZPAZETATMX_FLTK ${FLTK_SRC})
66 | 	TARGET_LINK_LIBRARIES(AZPAZETATMX_FLTK AZPAZETATMX_GL ${OPENGL_LIBRARIES} ${FLTK_BASE_LIBRARY} ${FLTK_GL_LIBRARY})
67 | ENDIF()
68 | 


--------------------------------------------------------------------------------