DevCorner
Here you can find some of our libraries and packages. These packages are or were used in our own projects, so you will probably need some of these packages if you want or need to build some of our products yourself.
Langadia
Langadia is a framework for Free Pascal using SDL, Lua and OpenGL.
Table of Contents
About
Langadia has been started in January 2008 by the NoManGames team. It was planned to create an easy to use framework based upon SDL, OpenGL and Lua. It was designed to be the base for a next game title and also for smaller demos and tools. The project has been cancelled when NoManGames disbanded in mid 2008.
Technical
Langadia uses SDL, OpenGL and Lua to do its jobs.
Window creation and drawing
SDL is used to create a window in Langadia. As for now, this limits the number of available windows to one (as SDL only permits one window). However, as Langadia has been aimed at Game programming and 3D (with OpenGL) this should not be a too big drawback. Beneath SDL, two additional libraries are used:
SDL_image can load image files of different formats; supported are e.g. BMP, JPeg, PNG and TGA.
The second library is SDL_ttf, which loads fonts and renders them to off-screen bitmaps. Both libraries can be found at http://www.libsdl.org/projects/.
Rendering
For rendering, Langadia uses OpenGL. There are classes for loading and displaying images ("textures", in terms of OGL) and fonts (also treated as textures).
Scripting
Langadia includes a scripting interface and classes for using Lua. Lua is a lightweight, fast and easy to use scripting language. With the provided interface between Lua and Langadia (called Langadia Lua Scripting Interface, short LGLSI), it was even possible to write applications nearly completely in Lua (with a compiled application only as "loader"). Especially the internal widget set - which includes Forms, Labels, Buttons, Single and Multi Line Edits - can be handled in Lua.
Features
- Window creation and event handling
- Texture loading and management
- Scripting interface
- Font loading
- Mesh classes and OBJ loader
- Widget set (Forms, Labels, Buttons, Edits, Scrolling)
License
GNU GPL v.3 Logo: GNU GPL v.3 Logo
Langadia has been released under the terms of the GNU GPL v. 3.
Important Notice
Langadia is discontinued! The development stopped as NoManGames - the original developer - disbanded. The download is provided by RPdev in the hope that it will be useful to somebody out there, however, we cannot guarantee that there will be further improvements or even bug fixes. You are - nevertheless - invited to use and extend Langadia on you own. If you need some help or advice, feel free to use our forum.
Langadia++ 2
Langadia++ 2 is a class library base on Qt 4. It seeks to provide useful tools especially for game development.
Table of Contents
About
Langadia++ 2 is to some extend the successor of Langadia++. However, it is less a framework but rather a loose collection of classes. This makes it more flexible, what is what we really need, as it will be the base for upcoming projects.
Bug tracker
There is a bug tracker for Langadia++ 2, where you can give feedback (bugs, feature requests, ...).
Langadia++
Langadia++ is a platform independent framework based upon SDL, OpenGL.
Table of Contents
About
Langadia++ is the successor of Langadia. In contrary to Langadia, which is rather a collection of utilities for Free Pascal, Langadia++ is usually build as a dynamic library for C++. Despite it is designed mainly for game development, it is rather a framework than a engine.
Installation
Langadia++ is currently only available as source code. In order to install it, you will need to fetch and install the following components:
- CMake 2.6 (or higher)
- SDL, SDL_mixer, SDL_image, SDL_ttf each in version 1.2
- Lua 5.1 (or higher)
CMake is the build system used by Langadia++, the other packages are libraries needed by Langadia++. Note that you will need both the library binaries and the header and lib files!
If you have set up your system, download Langadia++ via our Download Centre. Then open up a terminal window and do the following:
tar xf langadia-$version.tar.gz
cd langadia-$version
mkdir build
cd build
cmake ..
make
sudo -c "make install"
Building Langadia++ under Windows OS
Langadia++ is mainly developed under Linux and therefore makes heavy use of the concepts and typical building steps used there. For Windows users, these steps are probably unusual and maybe even difficult to follow and understand. This article shall give you a introduction how to set up a working build environment for Langadia and how to build it.
Table of Contents
Setting up your system
Langadia++ uses CMake to manage its build process. Beneath, it requires a set of libraries to provides its functionality.
In order to build Langadia, you will require both the CMake toolchain and these libraries. Beneath, you will have to set up a environment to build C++ projects. As I assume that you are interested in a lightweight and but still feature rich environment, I will describe how to install and use the Code::Blocks IDE. However, other IDEs (including Eclipse or MS Visual Studio) should work pretty the same.
Installing Code::Blocks
Code::Blocks is an free to use, open source IDE mainly for C++ development. It can use a variety of compilers, however, I'll assume you want to use MinGW, a minimal GNU system for Windows, as it too is open source and will probably make less problems (especially, as Langadia probably will need some porting if it should compile with e.g. MS Visual C++ compiler).
The installation here is pretty easy: Just visit Code::Blocks' Download pages and go to "Binary packages". There, go further to the Microsoft Windows binaries and choose the Code::Blocks MinGW package. This package contains both the Code::Blocks IDE and the MinGW binary distribution. After installation, make sure that the MinGW binary directory is in your system's PATH environment variable. The binary directory is located in the installation directory of Code::Blocks under MinGW\bin. Usually, the installation should enter the path by it's own, so just be careful when you are ask if you want to change something to your system.
Installing CMake
CMake is a build system which became popular recently. It can be compared e.g. to the GNU Autotools tool chain, however it is a bit more intuitive and by this easier to learn for beginners. Just visit the Download page and select the Windows installer. After installation, enter the path to the cmake.exe to your PATH environment variable (otherwise you'll have to enter the full path later).
Setting up needed libraries
Langadia++ needs the following libraries to be build:
Download them all (choose if possible the binary+source packages, if you have no program to unpack the tar.gz archives, have a look at 7-zip) and unpack. Now you have to make sure, that the header files and the libraries (*.dll and *.lib) can be found by CMake. This can be easily archives by creation two environment variables:
- CMAKE_LIBRARY_PATH contains a list of directories where the DLL and LIB files are, e.g. CMAKE_LIBRARY_PATH=C:\SDL\lib;C:\SDL_image\lib
- CMAKE_INCLUDE_PATH contains a list of directories where the header files are, e.g. CMAKE_INCLUDE_PATH=C:\SDL\include;C:\SDL_image\include
Compiling Langadia++
Now your system should be ready to compile a own version of Langadia for you. So let's quickly go on.
Generating Makefiles and Project files
In the next step, we will use CMake to generate the "meta" information needed to build Langadia. CMake usually is used to create simple UNIX Makefiles. However, as we have no UNIX environment, these are useless. Note however, that it currently is possible to set up a UNIX-like environment!.
Beneath, CMake can also generate project files for some well known IDEs including Code::BLocks. So, open a console window and do the following:
mkdir build
cd build
cmake -G "CodeBlocks - MinGW Makefiles" -DCMAKE_INSTALL_PREFIX=C:\Langadia ..
First, change to the Langadia directory. (NOT the directory called Langadia inside the package, however!) Then we create a new directory "build" and change inside it. Then we call CMake. By passing -G "CodeBlocks - MinGW Makefiles" we tell CMake that we want it to generate Code::BLocks project files for us. The -DCMAKE_INSTALL_PREFIX=C:\Langadia option tells CMake the installation directory. By default, it will assume something like C:\Program Files\Langadia, so if this OK for you, you can just omit this option. At last, we have to give CMake the directory, where the file CMakeLists.txt is. As we are in the build subdirectory (remember?) the file is located in the parent directory, so we just pass "..".
Compiling Langadia++
Now, if CMake ran without errors, open the Code::Blocks IDE. There, go to File -> Open, go to the Langadia\build directory and open the file called Langadia++.cbp. Now, press Ctrl+F9 to build the library. Then, go to Build -> Select target -> install. Then again press Ctrl + F9, this time it will install Langadia (the header files needed to build applications using Langadia and the DLL) to the location you set by passing the -DCMAKE_INSTALL_PREFIX option. Note, if you want to rebuild Langadia, you have to go again to Build -> Select target and there, select all.
Build issues and known problems
CMake failes with some error message. What should I do?
First, check if your CMAKE_INCLUDE_PATH and CMAKE_LIBRARY_PATH environment variables are set correctly. Also make sure you have all files needed (this includes Header files (*.h), DLLs (*.dll) and LIB files (*.lib)). DLL and LIB files should be in the same directory!
Also check your compiler setup and that all paths are set correctly.
If you cannot find the reason, you can also ask in our forum, maybe we can help you there.
CMake ran fine, but when I try to compile Langadia, linking fails with some cryptic [xxx]_NULL_THUNK_DATA not found message.
Make sure the DLL and LIB files of the needed libraries are in the same location and can be found by CMake! Rebuild the Makefiles and project files by again calling CMake!. Delete the old build directory before to make sure, you have a fresh environment!
PasLua
PasLua is a port of the original C header files for the Lua scripting language to Free Pascal.
Table of Contents
About
PasLua has been created together with Langadia - a simple 2D/3D OpenGL and Free Pascal framework. Back then, we decided to make Lua the default scripting language used in Langadia, as Lua is lightweight and really fast. So, Lua is currently heavily used especially in game development and real time applications.
Download
PasLua can be downloaded via our Download Centre. The package there contains both the Free Pascal source files and the original C headers.
Features
PasLua - in contrary to e.g. the headers included in the official Free Pascal distribution - dynamically loads the Lua library and its functions at runtime. This is useful, as the header does not necessarily depend on every function still being present in the DLL. It is also usable, if you want to use Lua as a kind of "plug-in", meaning: You do want to check, whether it is available at program run time and not compile time. However, this means also another call when initializing you application, to load the library and the function pointers. Beneath, it also cuts off compatibility to Delphi AFAIR (as PasLua uses FPCs dynamic library loading functions).
Version & License
The current version of PasLua has been chosen to resemble the appropriate version of Lua it is written for. So PasLua currently is available in version 5.1.3. It also uses the same license as Lua itself: the MIT License. This license gives you huge freedom, as it allows both the Open Source and commercial usage.
Important notice
PasLua is not really actively developed any more, as the (Pascal) Langadia project has been cancelled and NoManGames - the former developer - has closed it's doors. However, PasLua is provided still, cause maybe it can still be useful to someone out there. If you encounter problems you can contact us (e.g. via our forum). If you ported PasLua to a newer version of Lua or fixed bugs, we would also be glad if you inform is - although you are not forced to do so ;-)
TUDAI
TUDAI Utilities is a small library collecting some functionality which tend to be needed from time to time.
About
It has been started in matter of a Artificial Intelligence (AI) course at the Technical University Dresden (TUD). It is a Java library, holding several classes for "day-to-day" things one usually reimplement on each project.
It is released under the terms of the MIT license.
Building
To build the Java archive, download the source package and in a console run Ant:
ant dist
The Jar should be build in the dist directory. Additionally, you can create Javadoc documentation, which is useful if you want to use the online help mechanisms of IDEs like Eclipse:
Download
The source package can be downloaded via our Download Center
Development
There is a page in our Project Management category. There, you also can find a bug tracker to inform us about bugs or request new features.