Orx - Portable Game Engine (Version 1.15)

If you have any questions or comments, come chat with us on Discord.

This engine is licensed under the very permissive zlib license, see the LICENSE file for details.

Changes

• IMPORTANT: Added support for internal memory-based resources, including: orxResource_SetMemoryResource(), hotreload support, WEBP-encoded orx:font:default & orx:texture:logo textures

• IMPORTANT: Added Trigger module to enable per-object hierarchical/cascaded event handling in config, using commands (new ScrollObject's input system relies on Triggers), added internal triggers to handle object's creation, deletion and physics collisions

• IMPORTANT: Added support for headless mode, using embedded plugins + __orxHEADLESS__ define

• IMPORTANT: Added support for manual parents for Animation & Frame sections

• IMPORTANT: Using a single float value as an object/camera/spawner Position will only set its Z component, e.g. Position = -1 <=> Position = (0, 0, -1)

• IMPORTANT: FX module overhaul, including: Bezier curves support, web easing curves (30) and user-defined float/vector FXs

• IMPORTANT: Added orxObject_FindChild()/orxObject_FindOwnedChild (and commands) to find objects inside a hierarchy based on their name/index

• IMPORTANT: Languages can now be added on-the-fly to the Locale module, Locale.LanguageList has been replaced by Local.Language to define the default language

• IMPORTANT: Invalid animation sets will not stop execution anymore, using an unknown current/target anim name will be ignored (useful for recursive calls on hierarchies with diverging animation sets)

• IMPORTANT: Init-ed projects can now be re-init-ed to add/remove/update extensions

• IMPORTANT: Added tailored ExtensionTemplate.ini to init-ed projects, describing all config properties used by enabled extensions

• IMPORTANT: An optional wrap around and FX can now be applied to shader time parameters

• IMPORTANT: Bundle & Scroll extensions are now enabled by default for newly created projects using init

• IMPORTANT: Literal positions & pivot overrides will now work properly, no matter the IgnoreFromParent settings

• IMPORTANT: Min deployment OS version for MacOS is now 10.10

• IMPORTANT: Removed redundant orxClock_GetNext()

• IMPORTANT: default debug64 configurations has been replaced by debuguniv64 on MacOS

• IMPORTANT: Added typo detector for config values, using the Damerau-Levenshtein edit distance calculation algorithm (can be disabled)

• IMPORTANT: Added support for white, pink & brownian noises and sine, square, triangle & sawtooth (A-440 Hz) audio wave streams

• IMPORTANT: @ is now supported as the self-section identifier for config lazy commands

• IMPORTANT: Added orxInput_PushSet()/_PopSet() (+ associated commands) to handle input sets in a similar fashion to config sections

• IMPORTANT: The [Color] section can now be extended/overridden in the main config file

• New Mod init extension (based on ibxm) has replaced the former pocketmod-based one: FastTracker 2 .XM & Scream Tracker 3 .S3M formats are now supported

• Added SNDH init extension (based on AtariAudio) to play Atari ST sound files

• Added Cheat code (pass phrases/input sequences) init extension

• Added Inspector init extension (to inspect objects & associated config at runtime)

• Added support for new mouse cursors (hresize -> resize_ew, vresize -> resize_ns, resize_nesw, resize_nwse, resize_all & not_allowed)

• Improved clock's internal sleep accuracy to prevent oversleeping and micro-stuttering

• FPS counter isn't rendered on debug viewports anymore

• Objects with bodies can now age (but collisions won't be resolved during aging)

• Color literals can now be used in numeric random expressions, with or without steps

• Color literals are now supported through exposed config API and can be used for all available color spaces

• Added orxREMAP(), orxVector_Remap() & orxVector_Mod() (+ associated commands/aliases)

• Fixed auto-resize behavior of multiple viewports linked to the same texture

• Improved orxFontGen's log output

• Muted many unessential warning messages that spam logs in some valid use cases

• Added Input.Load, Input.Save and Input.ClearSet commands (+ orxInput_ClearSet()), orx:input:console & orx:input:profiler as internal input sets

• Added orxConfig_GetDefaultParent() & commands Config.SetDefaultParent/Config.GetDefaultParent

• Added Clock.Pause & Clock.IsPaused commands

• Added Object.(Add|Remove)BodyPart & Object.SetBody commands

• Physics simulation will now be ignored for objects linked to a paused clock

• Objects linked to a paused clock will not be updated

• Commands *ToSPherical & *ToCartesian now use degrees instead of radians

• Command.Evaluate can now take an optional GUID parameter

• Added orxObject_SetFXTime[Recursive]()/_GetFXTime() (+ associated commands)

• Added orxObject_ResetActiveTime[Recursive]() & command Object.ResetActiveTime

• Updated to latest Scroll (headers-only, OnFX* methods, ScrollObject::Find[Owned]Child/Get[Owned]Child, ScrollObject inputs & triggers support, etc.)

• Many misc fixes, optimizations and additions

Summary

Orx is a 2D-oriented, data-driven, portable game engine focused primarily on ease of use and powerful features.
See below for a list of supported platforms.

This is a release candidate for orx v1.15. If you find any bugs,
please report them on the forum, in the "Bug report - Feature request" board,
or via orx's issue page/tracker.

Some notable features of the engine are:

• powerful config system that makes orx data-driven and provides an easy to use load/save system
• hardware-accelerated rendering that provides: translation, anisotropic scale, rotation,
  transparency (alpha blending), different blending modes, coloring, tiling and mirroring
• advanced rendering features such as MRT (Multiple Render Targets), offscreen rendering, flexible pipeline & easy compositing
• advanced resource management allowing for easy multi-platform data support and patching
• automatic hotloading of resources upon modification on disk drastically shortens iteration times
• timelines and commands modules allow for config-driven scripting-like features
• interactive console can execute commands at runtime (very useful for tweaking/debugging purposes)
• advanced animation engine (including a chaining graph & custom animation events for synchronization)
• fragment (pixel) shader support
• visual FXs based on curve combinations
• integrated runtime profiler (with graphical display) to easily spot which parts of your game need to be optimized
• collision handling and rigid body physics
• camera/viewport scheme allowing multiple views displayed with camera translation, zoom and rotation
• generic input system that abstracts keyboard, mouse, joystick, touch and accelerometer inputs
• powerful localization module (for localized texts, audio, graphics, etc.)
• spawners (provides an easy way to create particles or projectiles)
• 3D positioning using "scene nodes"
• custom bitmap font support
• automatic differential scrolling and depth scaling upon request
• fully featured and extensible sound system (WAV/MP3/OGG support, streams, hierarchical buses, filters, spatialization, etc.)
• clock system that provides time consistency and allows time stretching + high precision timers
• event manager
• unicode support with UTF-8 encoding
• plugin system
• screenshot capture tool (supports bmp, png, jpg, qoi, tga and dds)

See orx's wiki for detailed information, including:

• initial setup
• beginner's guide
• tools
• samples
• detailed tutorials (both official and community-made ones)

See the doc/html directory for the doxygen documentation of orx's API.
The documentation for the latest release version is available here at orx's homepage.

Supported Platforms

The engine compiles and is tested for:

• Linux (x86/x86-64 with codelite, codeblocks and GNU makefile)
• Windows (x86/x86-64 with vs2017, vs2019 & vs2022, x86/x86-64 mingw-w64 (8.1.0) with codelite, codeblocks and GNU makefile)
• MacOS X (x86/x86-64 with xcode or x86/x86-64 with codelite, codeblocks and GNU makefile), version 10.6+
• iOS (iPhone/iPod Touch/iPad, simulator & device with xcode)
• Android (NDK build files, simulator & device)

Versions

Those are not revision versions but link/run versions.
Orx library can be compiled as a static or a dynamic library.
In addition to these modes, orx can be compiled as an embedded version or not.

Orx's core is basically platform-independent. All the platform/OS-dependent features
are implemented via plugins. These plugins can be loaded at runtime (hotplug) or
they can be embedded at linktime.

If you use the non-embedded versions, you'll have to specify which plugins to use.
This is more fl...

Orx - Portable Game Engine (Version 1.14)

Email iarwain [at] orx-project.org to contact the author; or, better, check orx's homepage for the most up-to-date contact information.
You can also come chat with us if you have any questions or comments.

This engine is licensed under the very permissive zlib license, see the LICENSE file for details.

Changes

• IMPORTANT: Android build system has been revamped & simplified and supports automatic downloading/updating of dependencies

• IMPORTANT: Major Android revamp with better physical keys support and more flexible VSync/refresh rate support

• IMPORTANT: Added a new 'Bundle' init extension that is fully customizable, is high performance even for a huge amount of tiny files, supports encryption & compression, cascading resource filtering, any other resource type as transport, external packages & in-executable storage and does auto-discovery of resources to pack. The old 'Archive' init extension has been retired

• IMPORTANT: Added config property AllowSleep for the core clock, trading potential occasional micro-stuttering for lower CPU/battery usage

• IMPORTANT: Removed config property MinFrequency from the render section (now handled directly as maxed modifier in the core clock section)

• IMPORTANT: OpenGL ES default float precision for shaders has been changed mediump -> highp

• IMPORTANT: Removed support for OpenGL control tear extension for swap intervals as it was introducing tearing artifacts for very short frames

• IMPORTANT: Part names have been replaced by the parts themselves (orxBODY_PART *) in orxPHYSICS_EVENT_PAYLOAD

• IMPORTANT: Group parameter has been added to orxRESOURCE_FUNCTION_LOCATE callbacks & storage field to orxRESOURCE_EVENT_PAYLOAD, orxResource_GetNextCachedLocation() now has an additional output storage argument()

• IMPORTANT: Renamed orxSoundSystem_CreateStreamFromFile() -> orxSoundSystem_LoadStream() & orxTexture_CreateFromFile() -> orxTexture_Load()

• IMPORTANT: Removed orxSound_GetSample() and added orxSound_GetSampleInfo() & orxSound_SetSampleData()

• IMPORTANT: Added support for '@' as the current section for all config commands when invoked from config

• IMPORTANT: Config property Input.JoyIDList now defaults to a list containing the first four joystick IDs

• IMPORTANT: OnPrepare object command will now be run after the orxOBJECT_EVENT_PREPARE event: object's owner will now be available from the OnPrepare command when created through ChildList or has a ParentCamera

• IMPORTANT: Default storages of resource groups can now be removed/re-added at a different priority (they default to the lowest one)

• IMPORTANT: F5 is now the default key to pause/unpause the embedded profiler & F8 the default key to show/hide the profiler's history

• IMPORTANT: Added support for FrameIndex for animations made with the multiple files mode

• IMPORTANT: ScrollObject::SetAnim() now defaults to a recursive behavior

• IMPORATNT: orxString_NPrint() now takes the size of the buffer including the terminating null character (no need for size + 1 as parameter any longer)

• IMPORTANT: Removed orxString_Print(), orxString_NPrint() should be used instead

• IMPORTANT: Returning an empty value for OnPrepare & OnDelete commands is now treated as "false" (ie. abort)

• IMPORTANT: Added System config values (Bits, Build, Endianness, Platform & Processor) + System command for queries

• IMPORTANT: Added support for optional conditions in config includes: @<condition_command>?file.ini@ or @<system_var>?file.ini@

• IMPORTANT: Added support for no-sorting at a group level for cameras (allows rendering dozen of thousands of objects inside those groups, albeit with no sorting)

• Config property Display.ContentScale will now report the ratio between the framebuffer size and the display dimension (useful for HiDPI/Retina displays)

• Updated all external dependencies to their latest versions circa early 2023

• Returning orxSTATUS_FAILURE when handling event orxSPAWNER_EVENT_WAVE_START now prevents the wave from spawning

• When a Prefix is defined for an animation, a frame will now inherit TextureOrigin, TextureSize & FrameIndex from its non-prefixed parent frame

• Added config property OnSpawn to spawners, used to run commands on spawned objects

• When a spawner is set to UseSelfAsParent, the spawned object's ownership can be changed during the OnCreate phase (though this will prevent them from being cleaned if CleanOnDelete was also requested)

• A 0-scale object is now officially supported as a way to bypass its rendering

• Object.SetColor now accepts color literals

• Added internal texture named 'transparent', which is a 1x1 black transparent texture (can be reference from config)

• Updated the default temporary bitmap when doing asynchronous loads to that transparent one (previously a white opaque one was used)

• Added support for verbose debugging logs to the setup tool (levels: 0 - 5)

• orxObject_SetRelativePivot() is now public and takes graphic alignment flags

• Added functions orxObject_SetAnimTime(), orxObject_SetAnimTimeRecursive() & orxObject_GetAnimTime() and associated commands

• Added orxResource_GetCacheCount(), orxResource_GetNextCachedLocation() & orxResource_UnregisterType()

• Added support for runtime console font scaling (config property Render.ConsoleFontScale)

• Audio stream, audio sample and sound creation from file is now entirely asynchronous to prevent any performance spike

• Miniaudio soundsystem plugin now supports running when no audio device is available

• Added the following new commands: Physics.EnableSimulation, Physics.GetCollisionFlagName & Physics.GetCollisionFlagValue

• Added multiple new math/vector commands

• Better handling of localized graphics for animation frames

• Negative audio volumes are now supported for better transitions using FXs

• All display plugins now use GL_TRIANGLES instead of GL_TRIANGLE_STRIP making their output much more readable when using an external debug tool

• Execution can now be aborted if command line params have been displayed by returning orxSTATUS_FAILURE when handling the new event orxSYSTEM_EVENT_PARAM_DISPLAY

• Added orxSYSTEM_EVENT_PARAM_READY event

• Added simple Sublime Text project with new projects created with the init utility

• Many misc fixes, optimizations and additions

Summary

Orx is a 2D-oriented, data-driven, portable game engine focused primarily on ease of use and powerful features.
See below for a list of supported platforms.

This is a release candidate for orx v1.14. If you find any bugs,
please report them on the forum, in the "Bug report - Feature request" board,
or via orx's issue page/tracker.

Some notable features of the engine are:

• powerful config system that makes orx data-driven and provides an easy to use load/save system
• hardware-accelerated rendering that provides: translation, anisotropic scale, rotation,
  transparency (alpha blending), different blending modes, coloring, tiling and mirroring
• advanced rendering features such as MRT (Multiple Render Targets), offscreen rendering, flexible pipeline & easy compositing
• advanced resource management allowing for easy multi-platform data support and patching
• automatic hotloading of resources upon modification on disk drastically shortens iteration times
• timelines and commands modules allow for config-driven scripting-like features
• interactive console can execute commands at runtime (very useful for tweaking/debugging purposes)
• advanced animation engine (including a chaining graph & custom animation events for synchronization)
• fragment (pixel) shader support
• visual FXs based on curve combinations
• integrated runtime profiler (with graphical display) to easily spot which parts of your game need to be optimized
• collision handling and rigid body physics
• camera/viewport scheme allowing multiple views displayed with camera translation, zoom and rotation
• generic input system that abstracts keyboard, mouse, joystick, touch and accelerometer inputs
• powerful localization module (for localized texts, audio, graphics, etc.)
• spawners (provides an easy way to create particles or projectiles)
• 3D positioning using "scene nodes"
• custom bitmap font support
• automatic differential scrolling and depth scaling upon request
• fully featured and extensible sound system (WAV/MP3/OGG support, streams, hierarchical buses, filters, spatialization, etc.)
• clock system that provides time consistency and allows time stretching + high precision timers
• event manager
• unicode support with UTF-8 encoding
• plugin system
• screenshot capture tool (supports bmp, png, jpg, qoi, tga and dds)

See orx's wiki for detailed information, including:

• initial setup
• beginner's guide
• tools
• samples
• detailed tutorials (both official and community-made ones)

See the doc/html directory for the doxygen documentation of orx's API.
The documentation for the latest release version is [available here](https://orx-project.org/orx/doc...

Orx - Portable Game Engine (Version 1.13)

Email iarwain [at] orx-project.org to contact the author; or, better,
check orx's homepage for the most up-to-date contact information.
You can also come chat with us
if you have any questions or comments.

This engine is licensed under the very permissive zlib license,
see the LICENSE file for details.

Changes

• IMPORTANT: Added support for VS2022 and retired support for VS2015

• IMPORTANT: Added config-driven command execution for objects with OnPrepare (can optionally reject object creation), OnCreate & OnDelete (can optionally reject object deletion and remove itself) & Object.SetOnDelete command (which can be called from inside OnDelete for cascading effect)

• IMPORTANT: orxObject_Delete() now only returns orxSTATUS_SUCCESS if the object was actually deleted

• IMPORTANT: Added support for position literals with optional offset (which honors UseParentSpace and supports regular/stepped randomization) and temporary pivot override (for flexible parent/child) alignment to objects

• IMPORTANT: Added support for pivot literals to objects & graphics

• IMPORTANT: Added native arm64 support for MacOS 11/XCode 12.x

• IMPORTANT: Added orxMovie (MPEG1/MP2) init extension, based on the PL_MPEG library, that adds config-driven movie support to objects & command Object.GetMovieDuration

• IMPORTANT: Added compressed texture/icon/cursor support for desktop versions (GLFW display plugin) using Basis Universal (UASTC -> ASTC/BC7)

• IMPORTANT: Added support for the QOI image format to all plugins/platforms

• IMPORTANT: Added orxMod (ProTracker MOD) init extension, based on the pocketmod library, that adds config-driven MOD support to objects

• IMPORTANT: The OpenAL, Android & iOS SoundSystem plugins and their external dependencies (OpenAL/OpenAL-Soft, Tremolo & linsndfile) have been removed

• IMPORTANT: Added a new SoundSystem plugin based on MiniAudio that covers all target platforms: all platforms now support loading OGG, WAV & MP3 files as well as writing WAV files, on Windows the audio backend will now update on-the-fly to the one selected by the user

• IMPORTANT: Removed orxSoundSystem_SetSampleData() and replace stream packet payload's as16SampleList with afSampleList (samples are now 32bit floats)

• IMPORTANT: Added support for config-driven filters for both sounds and buses, including commands: supports internal filters (biquad, low|high|band pass, low|high shelf, notch, peaking & delay) and user-defined custom filters (code only) + orxSOUND_EVENT_SET_PARAM event

• IMPORTANT: Added support for multiple sound listeners (none by default, deactivating sound spatialization globally)

• IMPORTANT: Added support for sound panning (including commands), sound spatialization has been entirely revamped and is now data-driven & independent of the channel count (off by default with no listeners)

• IMPORTANT: Removed obsolete SoundSystem config properties StreamBufferSize & StreamBufferNumber, sounds can now optionally be muted when the application is sent to background (on by default)

• IMPORTANT: Pitch FXs are now multiplicative instead of additive (neutral value is now 1 instead of 0)

• IMPORTANT: The sound itself is now part of the payload of all sound events (ie. not bus/recording ones), including stream packets

• IMPORTANT: The stream name of a stream event is now part of the stInfo substructure

• IMPORTANT: The send of a stream packet is now the object, consistent with other non-recording/non-bus sound events

• IMPORTANT: Added the concept of group to orxLocale: text, texture & sound can now be optionally localized independently (as well as user-defined custom groups)

• IMPORTANT: Config property Object.FXDelayList has been removed & orxObject_Add[Unique]FXRecursive() now take a propagation delay parameter

• IMPORTANT: GLFW display plugin now sets max shader version to 410 as 'varying' has been removed in 420

• IMPORTANT: orxInput_EnableSet() now creates the set if it wasn't already present

• IMPORTANT: orxArchive now accepts root paths in storage definitions, using : as separator (eg. Texture = data.zip:texture)

• IMPORTANT: The C locale is now enforce upon initialization to prevent any conversion issues if the locale was modified by an external library such as GTK

• IMPORTANT: Object name is now available from inside orxOBJECT_EVENT_PREPARE event handlers

• IMPORTANT: Spawners with UseSelfAsParent will now detach spawned objects upon deletion to maintain their location with respect to the world

• IMPORTANT: Renamed orxAnim_GetNextEvent() -> orxAnim_GetEventAfter() & Added newer version of orxAnim_GetNextEvent() to support multiple 0-length frames in a row or events associated to a 0-length frame

• IMPORTANT: orxResource_Seek() & orxResource_Tell() now returns -1 upon failure

• IMPORTANT: Added config property Display.DebugOutput to enable OpenGL debug output when available (OpenGL 4.3+)

• Migrated init & setup utilities from Ren-C to Oldes Rebol3 for better future proofing and better platforms support

• Setup will not create .bash_profile anymore on Linux/MacOS if it didn't already exist

• Added UNC paths support to orxFile on Windows

• Added convenience helpers orxCOMMAND_REGISTER() & orxCOMMAND_UNREGISTER()

• Added read-only config property Display.MaxTextureSize, filled during display's initialization

• orxColor_ToRGBA() now rounds RGB components during conversion (was flooring before)

• Color literals aliases now inherits from local section: this permits to derive the Color section for local overrides while maintaining alias consistency

• orxDisplay_SetVideoMode() now accepts zero-ed values for width, height, depth & refresh rate and will use current desktop values instead

• orxSpawner_GetWaveSize() will now always return the spawner's wave size value, even when not in wave mode

• orxSpawner_Spawn() can now accept orxU32_UNDEFINED as count to use the spawner's internal wave size

• orxConfig_ReloadHistory() will not clear sections that were not originating from a file anymore (such as [Color])

• Added command Config.RenameSection

• Added orxRemote init extension to access remote resource over HTTP/1.1 (mostly intended as proof-of-concept/dev feature)

• Added orxTexture_Get() to replace orxTexture_CreateFromFile()/orxTexture_Delete() calls when dealing with known existing textures

• Fixed frame children hierarchy not being correctly re-processed when a frame was deleted

• orxResource_ClearCache() can now take an optional group as parameter & added command Resource.ClearCache

• orxResource_RemoveStorage() (and command Resource.RemoveStorage) can now target all groups and/or all storages in a single call

• Added orxResource_Sync() to update all cached resource based on current group/storage definitions and command Resource.Sync

• orxArchive now reads/decompresses inside Read() (previously inside Open()) so as to not block calling thread

• Added bLast field to stream packets to allow stream termination from an event handler

• The number of channels and the sample rate of an empty music stream can now be defined in config

• Added orxInput_RemoveSet(), orxINPUT_EVENT_REMOVE_SET event & Input.RemoveSet command

• Added support for HTML web colors to viewport's BackgroundColor property

• Better handling of web literals/vector values mixes (ie. list-based randoms) for object, viewport, FX and graphic color properties

• Added commands Object.GetActiveTime, Object.ApplyTorque, Object.ApplyForce & Object.ApplyImpulse

• Added orxObject_[Get|Set][Literal]IgnoreFlags() and commands Object.SetIgnoreFlags & Object.GetIgnoreFlags

• Publicly exposed orxObject_SetLiteralLifeTime()

• Added orxObject_SetClockRecursive() & optional recursive argument to Object.SetClock

• Added FX config property Stagger to add an FX after all current existing ones, along with an optional signed time offset (which doesn't require Stagger) and orxFX_[Get|Set]Stagger()

• Added FX slot config property Stagger to add an FX slot after all current existing ones

• Added orx[Object|FXPointer]_[Get|Set]Frequency(), orxObject_SetFXFrequencyRecursive(), commands Object.[Get|Set]FXFrequency & config property Object.FXFrequency

• Added config property Object.FXRecursiveList to recursively apply FXs from the FXList property

• FX slots will now default to a linear curve when none is provided in config

• Better ANSI terminal detection on mac/XCode

• Non-config backed texts are not considered during config hot-reload anymore

• Updated orxStructure_LogAll & Command.LogAllStructures/Structure.LogAll to optionally log private structures

• Added orxGraphic_GetAlignFlags() & orxGraphic_AlignVector()

• Added Viewport.GetCorrectionRatio command

• Default stream sample rate if now 48kHz (previously 44.1kHz)

• Fixed NvOptimus/AmdPowerExpress exports in init template for non-MSVC Windows builds

• Better support for multiple partial init/exit of orx (ie. only specific modules) during a single life cycle of the application

• Misc fixes, optimizations and additions

Summary

Orx is a 2D-oriented, data-driven, portable game engine focused primarily on ease of use and powerf...

Orx - Portable Game Engine (Version 1.12)

Email iarwain [at] orx-project.org to contact the author; or, better,
check orx's homepage for the most up-to-date contact information.
You can also come chat with us
if you have any questions or comments.

This engine is licensed under the very permissive zlib license,
see the LICENSE file for details.

Summary

Orx is a 2D-oriented, data-driven, portable game engine focused primarily on ease of use and powerful features.
See below for a list of supported platforms.

This is a release candidate for orx v1.12. If you find any bugs,
please report them on the forum, in the "Bug report - Feature request" board,
or via orx's issue page/tracker.

Some notable features of the engine are:

• hardware-accelerated rendering that provides: translation, anisotropic scale, rotation,
  transparency (alpha blending), different blending modes, coloring, tiling and mirroring
• advanced rendering features such as MRT (Multiple Render Targets) support and easy compositing
• powerful config system that makes orx data-driven and provides an easy to use load/save system
• powerful resource management allowing for easy multi-platform data support and patching
• automatic hotloading of resources upon modification on disk shortens drastically iteration times
• timelines and commands modules allow for config-driven scripting-like features
• interactive console can execute commands at runtime (very useful for tweaking/debug purposes)
• advanced animation engine (including a chaining graph & custom animation events for synchronization)
• fragment (pixel) shader support
• visual FXs based on curve combinations
• integrated runtime profiler (with graphical display) to easily spot which parts of your game need to be optimized
• collision handling and rigid body physics
• camera/viewport scheme allowing multiple views displayed with camera translation, zoom and rotation
• generic input system that abstracts keyboard, mouse, joystick, touch and accelerometer inputs
• powerful localization module
• spawners (provides an easy way to create particles or projectiles)
• 3D positioning using "scene nodes"
• custom bitmap font support
• automatic differential scrolling and depth scaling upon request
• music and spatialized sound support
• clock system that provides time consistency and allows time stretching + high precision timers
• event manager
• unicode support with UTF-8 encoding
• plugin system
• screenshot capture tool (supports bmp, png, jpg, tga and dds)

See orx's wiki for detailed information, including:

• initial setup
• beginner's guide
• tools
• samples
• detailed tutorials (both official and community-made ones)

See the doc/html directory for the doxygen documentation of orx's API.
The documentation for the latest release version is available here at orx's homepage.

Supported Platforms

The engine compiles and is tested for:

• Linux (x86/x86-64 with codelite, codeblocks and GNU makefile)
• Windows (x86/x86-64 with vs2015, vs2017 & vs2019, x86/x86-64 mingw-w64 (8.1.0) with codelite, codeblocks and GNU makefile)
• MacOS X (x86/x86-64 with xcode or x86/x86-64 with codelite, codeblocks and GNU makefile), version 10.6+
• iOS (iPhone/iPod Touch/iPad, simulator & device with xcode)
• Android (NDK build files, simulator & device)

Versions

Those are not revision versions but link/run versions.
Orx library can be compiled as a static or a dynamic library.
In addition to these modes, orx can be compiled as an embedded version or not.

Orx's core is basically platform-independent. All the platform/OS-dependent features
are implemented via plugins. These plugins can be loaded at runtime (hotplug) or
they can be embedded at linktime.

If you use the non-embedded versions, you'll have to specify which plugins to use.
This is more flexible but also requires additional files (the plugins themselves).
The embedded version will store everything in orx's library, meaning you won't be able
to choose which plugin to use at runtime, but will also be more compact. This will
also make orx run considerably faster.

From the download page you'll find precompiled binaries for Windows (x86), Linux (x86/x86-64), MacOS X (ppc/x86/x86-64),
iOS and Android, using the dynamic embedded versions only.
If you want to use the non-embedded versions (to use with your own plugins), you'll need to compile orx yourself from the source.
Everything compiles out-of-the-box for the hardware platforms cited above.

The embedded versions currently use:

• GLFW-based (+SOIL) plugins for display, joystick, keyboard and mouse for all non-iOS/non-Android platforms
• OpenAL-based (+libsndfile/stb_vorbis/tremor) plugins for sound for all platforms
• Box2D-based plugin for physics
• homemade plugin for 2D rendering
• OpenGL ES plugins for display on iOS and Android
• Touch/MultiTouch-based plugin for mouse on iOS and Android
• Accelerometer-based plugin for joystick on iOS and Android

All the 11 basic and advanced official tutorials are shipped with the dev packages, including precompiled release binaries.

Some tools (precompiled binaries only) are also shipped with the dev packages:

• orxCrypt : command line tool to encrypt/decrypt/merge multiple config files
• orxFontGen: command line tool (based on FreeType2) to generate custom bitmap fonts (.png texture & .ini config file) from TrueType fonts

Packages

You can download all the packages from sourceforge or github.
Here is a list with a small description for each package.

• orx-doc-1.12.zip : orx's API doxygen documentation
• orx-src-1.12.zip : orx's source code, ready for compile after running the setup script
• orx-dev-linux32-1.12.tar.bz2 : dynamic embedded binaries for Linux (x86), release/profile/debug + tools.
• orx-dev-linux64-1.12.tar.bz2 : dynamic embedded binaries for Linux (x86-64), release/profile/debug + tools.
• orx-dev-mac-1.12.zip : dynamic embedded binaries for MacOS X (x86/x86-64), release/profile/debug + tools.
• orx-dev-mingw-32-1.12.zip : dynamic embedded binaries for Windows (mingw/x86), release/profile/debug + tools.
• orx-dev-mingw-64-1.12.zip : dynamic embedded binaries for Windows (mingw/x86-64), release/profile/debug + tools.
• orx-dev-vs2015-32-1.12.zip : dynamic embedded binaries for Windows (Visual Studio 2015, x86), release/profile/debug + tools.
• orx-dev-vs2015-64-1.12.zip : dynamic embedded binaries for Windows (Visual Studio 2015, x86-64), release/profile/debug + tools.
• orx-dev-vs2017-32-1.12.zip : dynamic embedded binaries for Windows (Visual Studio 2017, x86), release/profile/debug + tools.
• orx-dev-vs2017-64-1.12.zip : dynamic embedded binaries for Windows (Visual Studio 2017, x86-64), release/profile/debug + tools.
• orx-dev-vs2019-32-1.12.zip : dynamic embedded binaries for Windows (Visual Studio 2019, x86), release/profile/debug + tools.
• orx-dev-vs2019-64-1.12.zip : dynamic embedded binaries for Windows (Visual Studio 2019, x86-64), release/profile/debug + tools.
• orx-full-ios-1.12.zip : static embedded binaries for iOS, release/profile/debug, simulator/device + doc + source + XCode project file.
• orx-dev-android-1.12.zip : static embedded binaries for Android, release/profile/debug (device).
• orx-dev-android-native-1.12.zip : static embedded binaries for Android Native, release/profile/debug (device).
• orx-tutorial-linux32-1.12.tar.bz2 : tutorials for Linux (x86)
• orx-tutorial-linux64-1.12.tar.bz2 : tutorials for Linux (x86-64)
• orx-tutorial-mac-1.12.zip : tutorials for MacOS X (x86/x86-64)
• orx-tutorial-mingw-32-1.12.zip : tutorials for Windows (mingw/x86)
• orx-tutorial-mingw-64-1.12.zip : tutorials for Windows (mingw/x86-64)
• orx-tutorial-vs2015-32-1.12.zip : tutorials for Windows (Visual Studio 2015, x86)
• orx-tutorial-vs2015-64-1.12.zip : tutorials for Windows (Visual Studio 2015, x86-64)
• orx-tutorial-vs2017-32-1.12.zip : tutorials for Windows (Visual Studio 2017, x86)
• orx-tutorial-vs2017-64-1.12.zip : tutorials for Windows (Visual Studio 2017, x86-64)
• orx-tutorial-vs2019-32-1.12.zip : tutorials for Windows (Visual Studio 2019, x86)
• orx-tutorial-vs2019-64-1.12.zip : tutorials for Windows (Visual Studio 2019, x86-64)

All the *-dev-* packages above include:

• orx release/profile/debug libraries used for linking
• runtime release/profile/debug orx libraries
• headers to include at compile time
• template files exposing which properties can be accessed using the config system (for user reference only, not needed by orx)

All the *-tutorial-* packages above include:

• heavily commented source code for 11 basic and advanced tutorials
• precompiled binaries (orx link library, orx runtime library)
• headers to incl...

Orx - Portable Game Engine (Version 1.11)

Email iarwain [at] orx-project.org to contact the author; or, better,
check orx's homepage for the most up-to-date contact information.
You can also come chat with us
if you have any questions or comments.

This engine is licensed under the very permissive zlib license,
see the LICENSE file for details.

Summary

Orx is a 2D-oriented, data-driven, portable game engine focused primarily on ease of use and powerful features.
See below for a list of supported platforms.

This is a release candidate for orx v1.11. If you find any bugs,
please report them on the forum, in the "Bug report - Feature request" board,
or via orx's issue page/tracker.

Some notable features of the engine are:

• hardware-accelerated rendering that provides: translation, anisotropic scale, rotation,
  transparency (alpha blending), different blending modes, coloring, tiling and mirroring
• advanced rendering features such as MRT (Multiple Render Targets) support and easy compositing
• powerful config system that makes orx data-driven and provides an easy to use load/save system
• powerful resource management allowing for easy multi-platform data support and patching
• automatic hotloading of resources upon modification on disk shortens drastically iteration times
• timelines and commands modules allow for config-driven scripting-like features
• interactive console can execute commands at runtime (very useful for tweaking/debug purposes)
• advanced animation engine (including a chaining graph & custom animation events for synchronization)
• fragment (pixel) shader support
• visual FXs based on curve combinations
• integrated runtime profiler (with graphical display) to easily spot which parts of your game need to be optimized
• collision handling and rigid body physics
• camera/viewport scheme allowing multiple views displayed with camera translation, zoom and rotation
• generic input system that abstracts keyboard, mouse, joystick, touch and accelerometer inputs
• powerful localization module
• spawners (provides an easy way to create particles or projectiles)
• 3D positioning using "scene nodes"
• custom bitmap font support
• automatic differential scrolling and depth scaling upon request
• music and spatialized sound support
• clock system that provides time consistency and allows time stretching + high precision timers
• event manager
• unicode support with UTF-8 encoding
• plugin system
• screenshot capture tool (supports bmp, png, jpg, tga and dds)

See orx's wiki for detailed information, including:

• initial setup
• beginner's guide
• tools
• samples
• detailed tutorials (both official and community-made ones)

See the doc/html directory for the doxygen documentation of orx's API.
The documentation for the latest release version is available here at orx's homepage.

Supported Platforms

The engine compiles and is tested for:

• Linux (x86/x86-64 with codelite, codeblocks and GNU makefile)
• Windows (x86/x86-64 with vs2015, vs2017 & vs2019, x86/x86-64 mingw-w64 (8.1.0) with codelite, codeblocks and GNU makefile)
• MacOS X (x86/x86-64 with xcode or x86/x86-64 with codelite, codeblocks and GNU makefile), version 10.6+
• iOS (iPhone/iPod Touch/iPad, simulator & device with xcode)
• Android (NDK build files, simulator & device)

Versions

Those are not revision versions but link/run versions.
Orx library can be compiled as a static or a dynamic library.
In addition to these modes, orx can be compiled as an embedded version or not.

Orx's core is basically platform-independent. All the platform/OS-dependent features
are implemented via plugins. These plugins can be loaded at runtime (hotplug) or
they can be embedded at linktime.

If you use the non-embedded versions, you'll have to specify which plugins to use.
This is more flexible but also requires additional files (the plugins themselves).
The embedded version will store everything in orx's library, meaning you won't be able
to choose which plugin to use at runtime, but will also be more compact. This will
also make orx run considerably faster.

From the download page you'll find precompiled binaries for Windows (x86), Linux (x86/x86-64), MacOS X (ppc/x86/x86-64),
iOS and Android, using the dynamic embedded versions only.
If you want to use the non-embedded versions (to use with your own plugins), you'll need to compile orx yourself from the source.
Everything compiles out-of-the-box for the hardware platforms cited above.

The embedded versions currently use:

• GLFW-based (+SOIL) plugins for display, joystick, keyboard and mouse for all non-iOS/non-Android platforms
• OpenAL-based (+libsndfile/stb_vorbis/tremor) plugins for sound for all platforms
• Box2D-based plugin for physics
• homemade plugin for 2D rendering
• OpenGL ES plugins for display on iOS and Android
• Touch/MultiTouch-based plugin for mouse on iOS and Android
• Accelerometer-based plugin for joystick on iOS and Android

All the 11 basic and advanced official tutorials are shipped with the dev packages, including precompiled release binaries.

Some tools (precompiled binaries only) are also shipped with the dev packages:

• orxCrypt : command line tool to encrypt/decrypt/merge multiple config files
• orxFontGen: command line tool (based on FreeType2) to generate custom bitmap fonts (.png texture & .ini config file) from TrueType fonts

Packages

You can download all the packages from sourceforge or github.
Here is a list with a small description for each package.

• orx-doc-1.11.zip : orx's API doxygen documentation
• orx-src-1.11.zip : orx's source code, ready for compile after running the setup script
• orx-dev-linux32-1.11.tar.bz2 : dynamic embedded binaries for Linux (x86), release/profile/debug + tools.
• orx-dev-linux64-1.11.tar.bz2 : dynamic embedded binaries for Linux (x86-64), release/profile/debug + tools.
• orx-dev-mac-1.11.zip : dynamic embedded binaries for MacOS X (x86/x86-64), release/profile/debug + tools.
• orx-dev-mingw-32-1.11.zip : dynamic embedded binaries for Windows (mingw/x86), release/profile/debug + tools.
• orx-dev-mingw-64-1.11.zip : dynamic embedded binaries for Windows (mingw/x86-64), release/profile/debug + tools.
• orx-dev-vs2015-32-1.11.zip : dynamic embedded binaries for Windows (Visual Studio 2015, x86), release/profile/debug + tools.
• orx-dev-vs2015-64-1.11.zip : dynamic embedded binaries for Windows (Visual Studio 2015, x86-64), release/profile/debug + tools.
• orx-dev-vs2017-32-1.11.zip : dynamic embedded binaries for Windows (Visual Studio 2017, x86), release/profile/debug + tools.
• orx-dev-vs2017-64-1.11.zip : dynamic embedded binaries for Windows (Visual Studio 2017, x86-64), release/profile/debug + tools.
• orx-dev-vs2019-32-1.11.zip : dynamic embedded binaries for Windows (Visual Studio 2019, x86), release/profile/debug + tools.
• orx-dev-vs2019-64-1.11.zip : dynamic embedded binaries for Windows (Visual Studio 2019, x86-64), release/profile/debug + tools.
• orx-full-ios-1.11.zip : static embedded binaries for iOS, release/profile/debug, simulator/device + doc + source + XCode project file.
• orx-dev-android-1.11.zip : static embedded binaries for Android, release/profile/debug (device).
• orx-dev-android-native-1.11.zip : static embedded binaries for Android Native, release/profile/debug (device).
• orx-tutorial-linux32-1.11.tar.bz2 : tutorials for Linux (x86)
• orx-tutorial-linux64-1.11.tar.bz2 : tutorials for Linux (x86-64)
• orx-tutorial-mac-1.11.zip : tutorials for MacOS X (x86/x86-64)
• orx-tutorial-mingw-32-1.11.zip : tutorials for Windows (mingw/x86)
• orx-tutorial-mingw-64-1.11.zip : tutorials for Windows (mingw/x86-64)
• orx-tutorial-vs2015-32-1.11.zip : tutorials for Windows (Visual Studio 2015, x86)
• orx-tutorial-vs2015-64-1.11.zip : tutorials for Windows (Visual Studio 2015, x86-64)
• orx-tutorial-vs2017-32-1.11.zip : tutorials for Windows (Visual Studio 2017, x86)
• orx-tutorial-vs2017-64-1.11.zip : tutorials for Windows (Visual Studio 2017, x86-64)
• orx-tutorial-vs2019-32-1.11.zip : tutorials for Windows (Visual Studio 2019, x86)
• orx-tutorial-vs2019-64-1.11.zip : tutorials for Windows (Visual Studio 2019, x86-64)

All the *-dev-* packages above include:

• orx release/profile/debug libraries used for linking
• runtime release/profile/debug orx libraries
• headers to include at compile time
• template files exposing which properties can be accessed using the config system (for user reference only, not needed by orx)

All the *-tutorial-* packages above include:

• heavily commented source code for 11 basic and advanced tutorials
• precompiled binaries (orx l...

Orx - Portable Game Engine (Version 1.10)

Email iarwain [at] orx-project.org to contact the author; or, better,
check orx's homepage for the most up-to-date contact information.
You can also come chat with us
if you have any questions or comments.

This engine is licensed under the very permissive zlib license,
see the LICENSE file for details.

Summary

Orx is a 2D-oriented, data-driven, portable game engine focused primarily on ease of use and powerful features.
See below for a list of supported platforms.

This is a release candidate for orx v1.10. If you find any bugs,
please report them on the forum, in the "Bug report - Feature request" board,
or via orx's issue page/tracker.

Some notable features of the engine are:

• hardware-accelerated rendering that provides: translation, anisotropic scale, rotation,
  transparency (alpha blending), different blending modes, coloring, tiling and mirroring
• advanced rendering features such as MRT (Multiple Render Targets) support and easy compositing
• powerful config system that makes orx data-driven and provides an easy to use load/save system
• powerful resource management allowing for easy multi-platform data support and patching
• automatic hotloading of resources upon modification on disk shortens drastically iteration times
• timelines and commands modules allow for config-driven scripting-like features
• interactive console can execute commands at runtime (very useful for tweaking/debug purposes)
• advanced animation engine (including a chaining graph & custom animation events for synchronization)
• fragment (pixel) shader support
• visual FXs based on curve combinations
• integrated runtime profiler (with graphical display) to easily spot which parts of your game need to be optimized
• collision handling and rigid body physics
• camera/viewport scheme allowing multiple views displayed with camera translation, zoom and rotation
• generic input system that abstracts keyboard, mouse, joystick, touch and accelerometer inputs
• powerful localization module
• spawners (provides an easy way to create particles or projectiles)
• 3D positioning using "scene nodes"
• custom bitmap font support
• automatic differential scrolling and depth scaling upon request
• music and spatialized sound support
• clock system that provides time consistency and allows time stretching + high precision timers
• event manager
• unicode support with UTF-8 encoding
• plugin system
• screenshot capture tool (supports bmp, png, jpg, tga and dds)

See the doc/html directory for the doxygen documentation of orx's API.
The documentation for the latest release version is available here at orx's homepage.

You can find details about the tutorials (as well as community-made ones), the tools and the data-driven side of orx
(ie. how to use the config system) on orx's wiki.
The English version is the most complete one.
Chinese and Spanish translations are entirely written and maintained by community members,
and they might be less accurate/somewhat outdated.

Supported Platforms

The engine compiles and is tested for:

• Linux (x86/x86-64 with codelite, codeblocks and GNU makefile)
• Windows (x86 with vs2012, x86/x86-64 with vs2013, vs2015 & vs2017 and mingw32 (6.3.0) with codelite, codeblocks and GNU makefile)
• MacOS X (x86/x86-64/ppc/ppc64 with xcode or x86/x86-64 with codelite, codeblocks and GNU makefile), version 10.5+
• iOS (iPhone/iPod Touch/iPad, simulator & device with xcode)
• Android (NDK build files, simulator & device)

Versions

Those are not revision versions but link/run versions.
Orx library can be compiled as a static or a dynamic library.
In addition to these modes, orx can be compiled as an embedded version or not.

Orx's core is basically platform-independent. All the platform/OS-dependent features
are implemented via plugins. These plugins can be loaded at runtime (hotplug) or
they can be embedded at linktime.

If you use the non-embedded versions, you'll have to specify which plugins to use.
This is more flexible but also requires additional files (the plugins themselves).
The embedded version will store everything in orx's library, meaning you won't be able
to choose which plugin to use at runtime, but will also be more compact. This will
also make orx run considerably faster.

From the download page you'll find precompiled binaries for Windows (x86), Linux (x86/x86-64), MacOS X (ppc/x86/x86-64),
iOS and Android, using the dynamic embedded versions only.
If you want to use the non-embedded versions (to use with your own plugins), you'll need to compile orx yourself from the source.
Everything compiles out-of-the-box for the hardware platforms cited above.

The embedded versions currently use:

• GLFW-based (+SOIL) plugins for display, joystick, keyboard and mouse for all non-iOS/non-Android platforms
• OpenAL-based (+libsndfile/stb_vorbis/tremor) plugins for sound for all platforms
• Box2D-based plugin for physics
• homemade plugin for 2D rendering
• OpenGL ES plugins for display on iOS and Android
• Touch/MultiTouch-based plugin for mouse on iOS and Android
• Accelerometer-based plugin for joystick on iOS and Android

All the 11 basic and advanced official tutorials are shipped with the dev packages, including precompiled release binaries.

Some tools (precompiled binaries only) are also shipped with the dev packages:

• orxCrypt : command line tool to encrypt/decrypt/merge multiple config files
• orxFontGen: command line tool (based on FreeType2) to generate custom bitmap fonts (.tga texture & .ini config file) from TrueType fonts

Packages

You can download all the packages from sourceforge or github.
Here is a list with a small description for each package.

• orx-doc-1.10.zip : orx's API doxygen documentation
• orx-src-1.10.zip : orx's source code, ready for compile after running the setup script
• orx-dev-linux32-1.10.tar.bz2 : dynamic embedded binaries for Linux (x86), release/profile/debug + tools.
• orx-dev-linux64-1.10.tar.bz2 : dynamic embedded binaries for Linux (x86-64), release/profile/debug + tools.
• orx-dev-mac-1.10.zip : dynamic embedded binaries for MacOS X (x86/x86-64), release/profile/debug + tools.
• orx-dev-mingw-1.10.zip : dynamic embedded binaries for Windows (mingw), release/profile/debug + tools.
• orx-dev-vs2013-32-1.10.zip : dynamic embedded binaries for Windows (Visual Studio 2013, x86), release/profile/debug + tools.
• orx-dev-vs2013-64-1.10.zip : dynamic embedded binaries for Windows (Visual Studio 2013, x86-64), release/profile/debug + tools.
• orx-dev-vs2015-32-1.10.zip : dynamic embedded binaries for Windows (Visual Studio 2015, x86), release/profile/debug + tools.
• orx-dev-vs2015-64-1.10.zip : dynamic embedded binaries for Windows (Visual Studio 2015, x86-64), release/profile/debug + tools.
• orx-dev-vs2017-32-1.10.zip : dynamic embedded binaries for Windows (Visual Studio 2017, x86), release/profile/debug + tools.
• orx-dev-vs2017-64-1.10.zip : dynamic embedded binaries for Windows (Visual Studio 2017, x86-64), release/profile/debug + tools.
• orx-full-ios-1.10.zip : static embedded binaries for iOS, release/profile/debug, simulator/device + doc + source + XCode project file.
• orx-dev-android-1.10.zip : static embedded binaries for Android, release/profile/debug (device).
• orx-dev-android-native-1.10.zip : static embedded binaries for Android Native, release/profile/debug (device).
• orx-tutorial-linux32-1.10.tar.bz2 : tutorials for Linux (x86)
• orx-tutorial-linux64-1.10.tar.bz2 : tutorials for Linux (x86-64)
• orx-tutorial-mac-1.10.zip : tutorials for MacOS X (x86/x86-64)
• orx-tutorial-mingw-1.10.zip : tutorials for Windows (mingw)
• orx-tutorial-vs2013-32-1.10.zip : tutorials for Windows (Visual Studio 2013, x86)
• orx-tutorial-vs2013-64-1.10.zip : tutorials for Windows (Visual Studio 2013, x86-64)
• orx-tutorial-vs2015-32-1.10.zip : tutorials for Windows (Visual Studio 2015, x86)
• orx-tutorial-vs2015-64-1.10.zip : tutorials for Windows (Visual Studio 2015, x86-64)
• orx-tutorial-vs2017-32-1.10.zip : tutorials for Windows (Visual Studio 2017, x86)
• orx-tutorial-vs2017-64-1.10.zip : tutorials for Windows (Visual Studio 2017, x86-64)

All the *-dev-* packages above include:

• orx release/profile/debug libraries used for linking
• runtime release/profile/debug orx libraries
• headers to include at compile time
• template files exposing which properties can be accessed using the config system (for user reference only, not needed by orx)

All the *-tutorial-* packages above include:

• heavily commented source code for 11 basic and advanced tutorials
• precompiled binaries (orx link library, orx ru...

Orx - Portable Game Engine (Version 1.9)

Email iarwain [at] orx-project.org to contact the author; or, better,
check orx's homepage for the most up-to-date contact information.
You can also come chat with us
if you have any questions or comments.

This engine is licensed under the very permissive zlib license,
see the LICENSE file for details.

Summary

Orx is a 2D-oriented, data-driven, portable game engine focused primarily on ease of use and powerful features.
See below for a list of supported platforms.

This is a release candidate for orx v1.9. If you find any bugs,
please report them on the forum, in the "Bug report - Feature request" board,
or via orx's issue page/tracker.

Some notable features of the engine are:

• hardware-accelerated rendering that provides: translation, anisotropic scale, rotation,
  transparency (alpha blending), different blending modes, coloring, tiling and mirroring
• advanced rendering features such as MRT (Multiple Render Targets) support and easy compositing
• powerful config system that makes orx data-driven and provides an easy to use load/save system
• powerful resource management allowing for easy multi-platform data support and patching
• automatic hotloading of resources upon modification on disk shortens drastically iteration times
• timelines and commands modules allow for config-driven scripting-like features
• interactive console can execute commands at runtime (very useful for tweaking/debug purposes)
• animation engine (including a chaining graph & custom animation events for synchronization)
• fragment (pixel) shader support
• visual FXs based on curve combinations
• integrated runtime profiler (with graphical display) to easily spot which parts of your game need to be optimized
• collision handling and rigid body physics
• camera/viewport scheme allowing multiple views displayed with camera translation, zoom and rotation
• generic input system that abstracts keyboard, mouse, joystick, touch and accelerometer inputs
• powerful localization module
• spawners (provides an easy way to create particles or projectiles)
• 3D positioning using "scene nodes"
• custom bitmap font support
• automatic differential scrolling and depth scaling upon request
• music and spatialized sound support
• clock system that provides time consistency and allows time stretching + high precision timers
• event manager
• unicode support with UTF-8 encoding
• plugin system
• screenshot capture tool (supports bmp, png, jpg, tga and dds)

See the doc/html directory for the doxygen documentation of orx's API.
The documentation for the latest release version is available here at orx's homepage.

You can find details about the tutorials (as well as community-made ones), the tools and the data-driven side of orx
(ie. how to use the config system) on orx's wiki.
The English version is the most complete one.
Chinese and Spanish translations are entirely written and maintained by community members,
and they might be less accurate/somewhat outdated.

Supported Platforms

The engine compiles and is tested for:

• Linux (x86/x86-64 with codelite, codeblocks and GNU makefile)
• Windows (x86 with vs2012, x86/x86-64 with vs2013, vs2015 & vs2017 and mingw32 (6.3.0) with codelite, codeblocks and GNU makefile)
• MacOS X (x86/x86-64/ppc/ppc64 with xcode or x86/x86-64 with codelite, codeblocks and GNU makefile), version 10.5+
• iOS (iPhone/iPod Touch/iPad, simulator & device with xcode)
• Android (NDK build files, simulator & device)

Versions

Those are not revision versions but link/run versions.
Orx library can be compiled as a static or a dynamic library.
In addition to these modes, orx can be compiled as an embedded version or not.

Orx's core is basically platform-independent. All the platform/OS-dependent features
are implemented via plugins. These plugins can be loaded at runtime (hotplug) or
they can be embedded at linktime.

If you use the non-embedded versions, you'll have to specify which plugins to use.
This is more flexible but also requires additional files (the plugins themselves).
The embedded version will store everything in orx's library, meaning you won't be able
to choose which plugin to use at runtime, but will also be more compact. This will
also make orx run considerably faster.

From the download page you'll find precompiled binaries for Windows (x86), Linux (x86/x86-64), MacOS X (ppc/x86/x86-64),
iOS and Android, using the dynamic embedded versions only.
If you want to use the non-embedded versions (to use with your own plugins), you'll need to compile orx yourself from the source.
Everything compiles out-of-the-box for the hardware platforms cited above.

The embedded versions currently use:

• GLFW-based (+SOIL) plugins for display, joystick, keyboard and mouse for all non-iOS/non-Android platforms
• OpenAL-based (+libsndfile/stb_vorbis/tremor) plugins for sound for all platforms
• Box2D-based plugin for physics
• homemade plugin for 2D rendering
• OpenGL ES plugins for display on iOS and Android
• Touch/MultiTouch-based plugin for mouse on iOS and Android
• Accelerometer-based plugin for joystick on iOS and Android

All the 11 basic and advanced official tutorials are shipped with the dev packages, including precompiled release binaries.

Some tools (precompiled binaries only) are also shipped with the dev packages:

• orxCrypt : command line tool to encrypt/decrypt/merge multiple config files
• orxFontGen: command line tool (based on FreeType2) to generate custom bitmap fonts (.tga texture & .ini config file) from TrueType fonts

Packages

You can download all the packages from sourceforge or github.
Here is a list with a small description for each package.

• orx-doc-1.9.zip : orx's API doxygen documentation
• orx-src-1.9.zip : orx's source code, ready for compile after running the setup script
• orx-dev-linux32-1.9.tar.bz2 : dynamic embedded binaries for Linux (x86), release/profile/debug + tools.
• orx-dev-linux64-1.9.tar.bz2 : dynamic embedded binaries for Linux (x86-64), release/profile/debug + tools.
• orx-dev-mac-1.9.zip : dynamic embedded binaries for MacOS X (x86/x86-64), release/profile/debug + tools.
• orx-dev-mingw-1.9.zip : dynamic embedded binaries for Windows (mingw), release/profile/debug + tools.
• orx-dev-vs2013-32-1.9.zip : dynamic embedded binaries for Windows (Visual Studio 2013, x86), release/profile/debug + tools.
• orx-dev-vs2013-64-1.9.zip : dynamic embedded binaries for Windows (Visual Studio 2013, x86-64), release/profile/debug + tools.
• orx-dev-vs2015-32-1.9.zip : dynamic embedded binaries for Windows (Visual Studio 2015, x86), release/profile/debug + tools.
• orx-dev-vs2015-64-1.9.zip : dynamic embedded binaries for Windows (Visual Studio 2015, x86-64), release/profile/debug + tools.
• orx-dev-vs2017-32-1.9.zip : dynamic embedded binaries for Windows (Visual Studio 2017, x86), release/profile/debug + tools.
• orx-dev-vs2017-64-1.9.zip : dynamic embedded binaries for Windows (Visual Studio 2017, x86-64), release/profile/debug + tools.
• orx-full-ios-1.9.zip : static embedded binaries for iOS, release/profile/debug, simulator/device + doc + source + XCode project file.
• orx-dev-android-1.9.zip : static embedded binaries for Android, release/profile/debug (device).
• orx-dev-android-native-1.9.zip : static embedded binaries for Android Native, release/profile/debug (device).
• orx-tutorial-linux32-1.9.tar.bz2 : tutorials for Linux (x86)
• orx-tutorial-linux64-1.9.tar.bz2 : tutorials for Linux (x86-64)
• orx-tutorial-mac-1.9.zip : tutorials for MacOS X (x86/x86-64)
• orx-tutorial-mingw-1.9.zip : tutorials for Windows (mingw)
• orx-tutorial-vs2013-32-1.9.zip : tutorials for Windows (Visual Studio 2013, x86)
• orx-tutorial-vs2013-64-1.9.zip : tutorials for Windows (Visual Studio 2013, x86-64)
• orx-tutorial-vs2015-32-1.9.zip : tutorials for Windows (Visual Studio 2015, x86)
• orx-tutorial-vs2015-64-1.9.zip : tutorials for Windows (Visual Studio 2015, x86-64)
• orx-tutorial-vs2017-32-1.9.zip : tutorials for Windows (Visual Studio 2017, x86)
• orx-tutorial-vs2017-64-1.9.zip : tutorials for Windows (Visual Studio 2017, x86-64)

All the *-dev-* packages above include:

• orx release/profile/debug libraries used for linking
• runtime release/profile/debug orx libraries
• headers to include at compile time
• template files exposing which properties can be accessed using the config system (for user reference only, not needed by orx)

All the *-tutorial-* packages above include:

• heavily commented source code for 11 basic and advanced tutorials
• precompiled binaries (orx link library, orx runtime libra...

Orx - Portable Game Engine (Version 1.8)

Email iarwain [at] orx-project.org to contact the author; or, better,
check orx's homepage for the most up-to-date contact information.
You can also come chat with us
if you have any questions or comments.

This engine is licensed under the very permissive zlib license,
see the LICENSE file for details.

Summary

Orx is a 2D-oriented, data-driven, portable game engine focused primarily on ease of use and powerful features.
See below for a list of supported platforms.

This is the final release for orx v1.8. If you find any bugs,
please report them on the forum, in the "Bug report - Feature request" board,
or via orx's issue page/tracker.

Some notable features of the engine are:

• hardware-accelerated rendering that provides: translation, anisotropic scale, rotation,
  transparency (alpha blending), different blending modes, coloring, tiling and mirroring
• advanced rendering features such as MRT (Multiple Render Targets) support and easy compositing
• powerful config system that makes orx data-driven and provides an easy to use load/save system
• powerful resource management allowing for easy multi-platform data support and patching
• automatic hotloading of resources upon modification on disk shortens drastically iteration times
• timelines and commands modules allow for config-driven scripting-like features
• interactive console can execute commands at runtime (very useful for tweaking/debug purposes)
• animation engine (including a chaining graph & custom animation events for synchronization)
• fragment (pixel) shader support
• visual FXs based on curve combinations
• integrated runtime profiler (with graphical display) to easily spot which parts of your game need to be optimized
• collision handling and rigid body physics
• camera/viewport scheme allowing multiple views displayed with camera translation, zoom and rotation
• generic input system that abstracts keyboard, mouse, joystick, touch and accelerometer inputs
• powerful localization module
• spawners (provides an easy way to create particles or projectiles)
• 3D positioning using "scene nodes"
• custom bitmap font support
• automatic differential scrolling and depth scaling upon request
• music and spatialized sound support
• clock system that provides time consistency and allows time stretching + high precision timers
• event manager
• unicode support with UTF-8 encoding
• plugin system
• screenshot capture tool (supports bmp, png, jpg, tga and dds)

See the doc/html directory for the doxygen documentation of orx's API.
The documentation for the latest release version is available here at orx's homepage.

You can find details about the tutorials (as well as community-made ones), the tools and the data-driven side of orx
(ie. how to use the config system) on orx's wiki.
The English version is the most complete one.
Chinese and Spanish translations are entirely written and maintained by community members,
and they might be less accurate/somewhat outdated.

Supported Platforms

The engine compiles and is tested for:

• Linux (x86/x86-64 with codelite, codeblocks and GNU makefile)
• Windows (x86 with vs2012, x86/x86-64 with vs2013 & vs2015 and mingw32 (5.3.0) with codelite, codeblocks and GNU makefile)
• MacOS X (x86/x86-64/ppc/ppc64 with xcode or x86/x86-64 with codelite, codeblocks and GNU makefile), version 10.5+
• iOS (iPhone/iPod Touch/iPad, simulator & device with xcode)
• Android (NDK build files, simulator & device)

Versions

Those are not revision versions but link/run versions.
Orx library can be compiled as a static or a dynamic library.
In addition to these modes, orx can be compiled as an embedded version or not.

Orx's core is basically platform-independent. All the platform/OS-dependent features
are implemented via plugins. These plugins can be loaded at runtime (hotplug) or
they can be embedded at linktime.

If you use the non-embedded versions, you'll have to specify which plugins to use.
This is more flexible but also requires additional files (the plugins themselves).
The embedded version will store everything in orx's library, meaning you won't be able
to choose which plugin to use at runtime, but will also be more compact. This will
also make orx run considerably faster.

From the download page you'll find precompiled binaries for Windows (x86), Linux (x86/x86-64), MacOS X (ppc/x86/x86-64),
iOS and Android, using the dynamic embedded versions only.
If you want to use the non-embedded versions (to use with your own plugins), you'll need to compile orx yourself from the source.
Everything compiles out-of-the-box for the hardware platforms cited above.

The embedded versions currently use:

• GLFW-based (+SOIL) plugins for display, joystick, keyboard and mouse for all non-iOS/non-Android platforms
• OpenAL-based (+libsndfile/stb_vorbis/tremor) plugins for sound for all platforms
• Box2D-based plugin for physics
• homemade plugin for 2D rendering
• OpenGL ES plugins for display on iOS and Android
• Touch/MultiTouch-based plugin for mouse on iOS and Android
• Accelerometer-based plugin for joystick on iOS and Android

All the 11 basic and advanced official tutorials are shipped with the dev packages, including precompiled release binaries.

Some tools (precompiled binaries only) are also shipped with the dev packages:

• orxCrypt : command line tool to encrypt/decrypt/merge multiple config files
• orxFontGen: command line tool (based on FreeType2) to generate custom bitmap fonts (.tga texture & .ini config file) from TrueType fonts

Packages

You can download all the packages from sourceforge or github.
Here is a list with a small description for each package.

• orx-doc-1.8.zip : orx's API doxygen documentation
• orx-src-1.8.zip : orx's source code, ready for compile after running the setup script
• orx-dev-linux32-1.8.tar.bz2 : dynamic embedded binaries for Linux (x86), release/profile/debug + tools.
• orx-dev-linux64-1.8.tar.bz2 : dynamic embedded binaries for Linux (x86-64), release/profile/debug + tools.
• orx-dev-mac-1.8.zip : dynamic embedded binaries for MacOS X (x86/x86-64), release/profile/debug + tools.
• orx-dev-mingw-1.8.zip : dynamic embedded binaries for Windows (mingw), release/profile/debug + tools.
• orx-dev-vs2013-32-1.8.zip : dynamic embedded binaries for Windows (Visual Studio 2013, x86), release/profile/debug + tools.
• orx-dev-vs2013-64-1.8.zip : dynamic embedded binaries for Windows (Visual Studio 2013, x86-64), release/profile/debug + tools.
• orx-dev-vs2015-32-1.8.zip : dynamic embedded binaries for Windows (Visual Studio 2015, x86), release/profile/debug + tools.
• orx-dev-vs2015-64-1.8.zip : dynamic embedded binaries for Windows (Visual Studio 2015, x86-64), release/profile/debug + tools.
• orx-full-ios-1.8.zip : static embedded binaries for iOS, release/profile/debug, simulator/device + doc + source + XCode project file.
• orx-dev-android-1.8.zip : static embedded binaries for Android, release/profile/debug (device).
• orx-dev-android-native-1.8.zip : static embedded binaries for Android Native, release/profile/debug (device).
• orx-tutorial-linux32-1.8.tar.bz2 : tutorials for Linux (x86)
• orx-tutorial-linux64-1.8.tar.bz2 : tutorials for Linux (x86-64)
• orx-tutorial-mac-1.8.zip : tutorials for MacOS X (x86/x86-64)
• orx-tutorial-mingw-1.8.zip : tutorials for Windows (mingw)
• orx-tutorial-vs2013-32-1.8.zip : tutorials for Windows (Visual Studio 2013, x86)
• orx-tutorial-vs2013-64-1.8.zip : tutorials for Windows (Visual Studio 2013, x86-64)
• orx-tutorial-vs2015-32-1.8.zip : tutorials for Windows (Visual Studio 2015, x86)
• orx-tutorial-vs2015-64-1.8.zip : tutorials for Windows (Visual Studio 2015, x86-64)

All the *-dev-* packages above include:

• orx release/profile/debug libraries used for linking
• runtime release/profile/debug orx libraries
• headers to include at compile time
• template files exposing which properties can be accessed using the config system (for user reference only, not needed by orx)

All the *-tutorial-* packages above include:

• heavily commented source code for 11 basic and advanced tutorials
• precompiled binaries (orx link library, orx runtime library)
• headers to include at compile time
• template files exposing which properties can be accessed using the config system (for user reference only, not needed by orx)
• build/project files

Compiling

###Important - first step:

**If you just downloaded the src package or cloned orx with mercurial or git, you will need to run the setup.bat / setup.sh script
that's located at its root before being able to compile the engine.
This script will download all the needed dependencies and generate all the project files for your platform.
T...