neoGFX C++ Application/Game Engine and Development Platform -- Coming Soon

Introduction

neoGFX is a C++ app/game engine and development platform targeted at app and game developers that wish to leverage modern GPUs for performant application user interfaces and game graphics.

Proposed Features:

• modern C++20 design including full exception safety supporting various widget allocation patterns (stack, member variable or free store);
• use of standard non-proprietary C++ data types including using standard string classes (UTF-8 encoding) and containers from the C++ standard library and Boost where possible;
• simple, easy to use multi-threaded event system (an improvement over traditional signals and slots);
• no baggage: neoGFX primarily contains only the GUI and graphics related functionality needed for creating apps and games;
• full library of widgets and layout managers specifiable in RJSON (Relaxed JSON) using the included GUI designer tool;
• CSS3 style sheet support with support for custom skins;
• scripting engine, neos, that will be able to support a wide range of scripting languages (on release: neoscript, JavaScript and Lua);
• sub-pixel text rendering;
• simple window style for specifying that a window is "nested" rather than being a separate native desktop window;
• "text_edit" widget supports multiple fonts, text colours (with optional gradient effects), colour emojis and rendering text in columns;
• "Green" and "Arcade" modes to optimize CPU power consumption, fight #ClimateChange!
• GPU shader rendered CSS3 compliant gradients with optional gaussian smoothing;
• MVC (model-view-controller) related classes supporting robust and fast app design;
• optional MDI support utilizing "nested" windows;
• 2D, 2.5D and 3D game support: sprites, objects and physics;
• Pure ECS (Entity-component-system) usable by both games and apps;
• flexible asset management: texture images (e.g PNGs) can be stored in .zip archives which can be optionally embedded inside the program binary accessible using simple URLs;
• support for OpenGL, DirectX and Vulkan.

Initial design goals will be:

• for the API to be as clean and easy to use as possible;
• no reliance on macro-based code generation used by certain other GUI libraries;
• to be as fast as possible (after all this is C++) with compiled binaries having as small a memory footprint as possible with no huge redistributables;
• 3rd party dependencies include: Boost, FreeType and HarfBuzz.

The plan is for v1.0 supported platforms to be Windows (desktop) and Linux (desktop) followed later with OS X, iOS and Android support.

Test executable demonstrating latest implemented features: .

neoGFX is open source currently licensed as GPLv3 with a commercial licence available when v1.0 is released.

The full library source code is available from: https://github.com/i42output/neogfx.git.

The library is also dependent on the neolib C++ utility library available from https://github.com/i42output/neolib.git.

neoGFX library documentation (work-in-progress in the form of a wiki) and the neoGFX forum can be found here.

Roadmap

Version	ETA	Features
v0.99	Q3, 2025	Windows OpenGL; widget library feature complete; GUI designer tool
v1.00	Q4, 2025	Linux OpenGL; Vulkan; scripting engine
v1.10	Q2, 2026	Android support; physics engine
v1.20	Q4, 2026	macOS support

Documentation

Documentation for neoGFX will appear on the Wiki, here.

Implementation Progress Log

neoGFX is still a work in progress (incomplete) so is not yet suitable for making apps or games. Currently neogfx has only been built for and tested on Windows.

April 2022

Progressing ClicksAndWhistles 3.0 the flagship neoGFX sample application, an open source multi-protocol chat client.

January 2021

Created neoGFX Chess sample application from scratch (including an AI) in less than 2 weeks demonstrating the maturity of neoGFX:

December 2020

Added advanced text effects, superscript/subscript etc to the font selection dialog:

September 2020

Shader based blurred outline (black) applied to colorized "material design" icons so they look legible on both dark and light backgrounds:

Work has begun in ernest on neoGFX Design Studio.

August 2020

Gradients can now be batched in the rendering pipeline allowing the same gradient with different bounding boxes to be applied without changing shader state. New filter shader created allowing, for example, enhanced gaussian-blur-based text rendering effects:

 

May 2020

Major neoGFX milestone reached: after reducing the default ECS physics step time from 10ms to 1ms a framerate of 450 FPS was achieved:

Fullscreen mode added.

neoGFX has two modes of operation: green and turbo. In green mode CPU usage is close to 0% and GPU rendering only happens if things change. In turbo mode FPS limits are turned off as can be seen in this screenshot. #neoGFX #gamedev #cpp #coding #ClimateAction

April 2020

Widget skinning support added. Tree view widget implemented. SDL removed as a dependency.

January 2020

New demonstration video of the responsiveness and performance of the neoGFX C++ game engine / app framework when dragging/resizing windows and scrolling window contents:

Major re-work of the GPU shader architecture and how ECS entities are rendered resulting in significant FPS performance improvements. Font glyphs can now be individually rendered with a gradient:

 

December 2019

Significant progress made with the UI resource compiler tool, nrc, that converts a UI described using Relaxed JSON (RJSON) into C++. Event and property systems refactored.

May 2019

Created a new text field widget. Added support for anchor-based layouts as used to align the "First field:" and "Second field:" labels of the text fields below:

February 2019

Started work on the scripting engine: this is an independent project called neos.

Januray 2019

Added 2D/3D mesh patch support to the ECS which is now used to compose the playing cards in the video poker sample:

November 2018

Implemented render to texture and easing (tweening) functions.

23rd September 2018

Implementation ongoing of the new pure entity-component-system (ECS) that will be used by neoGFX's game functionality; there is also the potential to use the ECS in the implementation of application widgets such as charting widgets.

Gradients are now a lot subtler in the default skin so there is less of an old fashioned "Web 2.0" look.

Disabled text is now displayed with 25% alpha (rather than 50%) so there is more of a contrast with non-disabled text (see "Radio 3"):

12th May 2018

neoGFX now renders on both nVIDIA GTX and AMD Radeon cards; significant FPS performance improvements.

20th March 2018

Finished implementing drop list widget (list always visible) and font selection dialog.

7th March 2018

Drop lists with optional "editable" (combo box) mode implemented. Status bar widget implemented. Support for high DPI displays added including automatic integer DPI scaling factor.

27th January 2018

Sprite plane broad phase collision detection is now done using a quadtree (2D) or an octree (3D).  Drop lists have been implemented; work is proceeding on making them support editable mode (aka combo box).  The 3D shading effect used for rendering push buttons is now more subtle (less shiny).

10th December 2017

The playing card sprites are now fully rendering in the neoGFX C++ sample application "Video Poker" as can be seen in this screenshot. neoGFX sprites are 2D/3D meshes (with physics) the faces of which can map to texture atlas sub-textures; the screenshot also demonstrates the mapping of sprites onto GUI widgets using transformation matrices:

 

26th November 2017

It is now possible to easily specify using a size policy that a widget's aspect ratio must be maintained when being laid out:

17th November 2017

Red black AABB tree for broad phase collision detection implemented:

11th November 2017

Sprites can now be added to a sprite plane during the physics/collision update loop:

22nd October 2017

Message box implemented:

16th October 2017

Window non-client related functionality implemented including window title bars:

12th October 2017

Bespoke icons for neoGFX have been commissioned, delivered and re-coloured; they will be used for standard menus (e.g. "File" and "Edit") and the message box:

6th August 2017

Implementation of item view editing is proceeding well; cell data entry is as simple as pressing the TAB key:

30th July 2017

Item view models have been refactored; now multiple item views can share the same item model but have individual item presentation models:

21st July 2017

2D collision detection (AABB for now, SAT to come later) and sprite sheet animation have been implemented in the game module:

16th May 2017

The neoGFX wiki has been setup at http://neogfx.io/wiki; library and framework documentation will be contained in the wiki.

21st April 2017

Progress made on the generic dynamic lexer which will be used by CSS3 parser and scripting language; invoking it is pretty simple:

9th April 2017 (Scotland Interval)

Support for fully CSS3 compliant gradients added.  Started work on a CSS3 parser; a simple visitor pattern will be used to set widget properties based on CSS3 style sheet contents.

23rd March 2017

Fixed a bug in the layout manager code: nested group box widgets now render perfectly:

22nd March 2017

Implemented group box widget. Started work on GUI designer tool:

16th March 2017

Support for mipmapped textures added. Colour emoji support implemented.

9th March 2017

Tab stops implemented in text_edit widget along with multi-line RTL text input.

7th February 2017

RTL text (e.g. Arabic) input implemented.

18th August 2016

Tired of signals and slots offered by more traditional GUI libraries some of which even use code generation in their implementation? You should be as signals and slots are an old solution to an old problem.  In neoGFX the alternative is modern simplicity at its finest:

button1.clicked([](){...});

As you can see C++ lambdas have made traditional signals and slots redundant.

If you want automatic event deregistration (traditional role of the "slot"):

neogfx::sink s;
s += button1.clicked([](){...});

When 's' is destroyed any associated event registrations are deregistered automatically.  Sink objects can be on the stack, member variables or the more traditional base class sub-object.

28th July 2016

Just cracked FAST sub-pixel text rendering (no longer does any FBO blitting).

18th July 2016

Finished implementing sub-pixel text rendering.

29th June 2016

Finished implementing the colour gradient selection widget:

17th June 2016

Finished implementing the colour selection tool, colour_dialog.

14th June 2016

Progress on the first neoGFX standard (modal) dialog the colour selection tool, colour_dialog, continues.

13th June 2016

A new website has been opened that will eventually host the neoGFX project: it is currently empty except for the new neoGFX forum!

12th June 2016

Line edits, spin boxes and sliders implemented. Support for modal dialogs added.

29th May 2016

Progress on text edit widget continues; support for outlined text effect added; word wrap implemented; cursor implemented.

25th May 2016

Progress on text edit widget continues (day three).

20th May 2016

Menus fully implemented along with keyboard mnemonic accelerators:

17th May 2016

Support for rendering underline text added.

16th May 2016

Support for font kerning added:

 

Improved non-sub-pixel text rendering by aligning characters on pixel boundaries.

Implementation of menus virtually complete (just mnemonic keyboard accelerators to do):

18th April 2016

Progress on menu widgets continues; as part of this support for multiple windows has been added.

12th April 2016

Menu bars almost implemented (which utilize new "flow" layout manager).

30th March 2016

Fixed various problems including problems with layout managers.

Toolbars implemented; used GLSL to render greyscale icons for disabled actions.

13th March 2016

Published several YouTube videos demoing 2D sprite physics:

5th March 2016

Fixed several issues. Logical coordinate system added with two automatic systems "GUI" and "Game"; GUI logical coordinate system has origin in top left corner whilst Game logical coordinate system has origin in bottom left corner and both modes update the coordinates automatically as a widget is resized; screenshot demoing this:

1st March 2016

I have decided to change neoGFX's scope: now instead of just being a GUI library neoGFX will be a combined GUI/game library.

Progress on implementing sprites continues; here is my version of "Hello, World!": Goldenrod Spaceship!:

Obviously one wouldn't normally create sprite images in-code like this and indeed neogfx::image will support loading standard image files such as .PNG directly from a file or from asset archives or from a file embedded in the executable (method used to load textures as seen in the previous three progress updates).  This in-code method might be useful to easily create simple widget elements.

20th February 2016

Buttons can now have a image:

19th February 2016

Progress on texture drawing continues, neogfx::image_widget implemented:

18th February 2016

Implementation of images and textures proceeding well:

9th February 2016

Tabs more or less implemented:

4th February 2016

Implemented changing focus by tabbing.

Just implemented radio buttons (after adding circle drawing primitives):

31st January 2016

Just implemented check boxes:

Improved text font glyph hinting and improved the handling of styles and added new "Slate" style.

29th January 2016

Keyboard and mouse navigation in the table view widget complete just selection left to do. Made some improvements to the style code and how widgets render their backgrounds. Improved test program so you can click the keypad buttons to change the style colour.

17th January 2016

Made some speed improvements related to widget layout and table view column size determination.

Change licence of source code to GPLv3 with a view to dual licensing it upon release of v1.0.

Migrated the source repository from svn to git; library source code is now publicly available.

24th November 2015

Event framework is taking shape; you can now register for push button pressed events.  Clicking on list view header view buttons now sorts list view items by column (with history).

23rd October 2015

Progress on the list view widget continues:

I've arrived at my final design for the item (list/tree) view widget model classes which uses type erased "generic iterators" as part of the interface.  You can choose different containers for the default item view model and a variable or fixed number of columns (fixed number of columns allows for in-place allocation/construction of item view cell data).  Custom models are also supported which can be used if a standard container is not desirable.

11th October 2015

It's only taken me just over six hours to switch from SFML to SDL. Test .exe is 35% bigger now... meh.

Tweaked how text is positioned in text widgets, should now be on a pixel boundary.

Sub-pixel text rendering is still on the to-do list; resuming implementation of list view widget.

7th October 2015

Just implemented middle button press/hold scrolling.

6th October 2015

Work has begun on list and tree view widget item models. 

It looks like I am going to have to switch from SFML to SDL as SFML does not provide everything I need.  Switching should be almost painless due to the layered design of the neoGFX.

4th October 2015

Scrollbars fully implemented:

3rd October 2015

With the aid of a few vodka red bulls progress on scrollbars continues.

30th September 2015

Now that I have widget clipping sorted (the OpenGL function glScissor() is ideal for this) work can begin in earnest on scrollbars.

13th September 2015

Took me most of the weekend to get basic (non-sub-pixel) text rendering using GLSL (Open GL shader language) working mainly because GLSL is so hard to debug and documentation (complete example) is hard to come by for specific use-cases. Here is the result (link above for executable).

10th September 2015

Just got a massive performance boost which should result in a great FPS: I fixed a silly bug whereby I was calling app().instance() instead of app::instance() in a couple of places .. doh! Bloody singletons! :) I was also not using my text glyph cache properly so HarfBuzz was getting invoked every widget layout and frame render.

4th September 2015

Not had much chance to work on the project during the past few weeks. Sub-pixel text rendering with Open GL shaders is still to do (hopefully this weekend); just implemented horizontal and vertical spacers for the layout managers.

10th August 2015

Text rendering almost sorted (just needs sub-pixel rendering).

1st August 2015

First ever neogfx screenshot:

20th June 2015

First code commit.