- SVG Importer
- Integration of new text capabilities
- Refraction, shadows and other effects
- Enhancing the 3D graphics capabilities
- Integration and completion of new vector graphics capabilities
-
SVG Importer
Overview: We would like to support importing SVG resources in the new engine. The vector graphics engine should already feature support for all basic SVG functionality, and this would consist in parsing SVG files to build the vector graphics tree.
As SVG is based on XML, our existing XMLParser class could be used.
Things not yet supported by our vector graphics engine should be noted for parallel development or future improvements.
Skills Required:
- Familiarity with basic object oriented programming concepts
- Familiarity with eC, C or another language in the C family (e.g. C++, C#, Java)
- Familiarity with SVG
Difficulty: Easy
Lead Mentor: Jérôme St-Louis <jerome@ecere.com>
Additional Mentor: Réjean Loyer <redj@ecere.com> -
Integration of new text capabilities
Overview: In our latest development branch we currently have two separate text renderers with different capabilities. We would like to integrate the new functionality found in the ec2 branch within our existing API. The new functionality includes improvements such as:
- Better font atlas management
- Support for drawing text along a curved path
- Blurred font outline support
- Clearer looking small fonts
- Shaping complex scripts with Harfbuzz
- Resolving installed fonts through either Fontconfig or the Windows registry
- Integration into our Surface class used by the GUI system
It would also be interesting to look into supporting vector font outlines. FreeType makes this available through the FT_Outline structure, which could possibly be converted to our vector graphics tree.
Skills Required:
- Familiarity with basic object oriented programming concepts
- Familiarity with eC, C or another language in the C family (e.g. C++, C#, Java)
- Familiarity with FreeType and/or HarfBuzz
- Familiarity with Shaders and OpenGL 3+ / OpenGL ES 2.0
Difficulty: Medium
Lead Mentor: Jérôme St-Louis <jerome@ecere.com>
Additional Mentor: Réjean Loyer <redj@ecere.com> -
Refraction, shadows and other effects
Overview: We hope to support a range of effects which could be applied to vector shapes and possibly text as well. These effects should most likely be implemented through shaders. We would like to support drop shadows, glassy/refractive, outlines and anything else that could help us achieve a great modern look for our user interface .
The ability to support SVG filter effects would be a plus.
Skills Required:
- Familiarity with basic object oriented programming concepts
- Familiarity with eC, C or another language in the C family (e.g. C++, C#, Java)
- Familiarity with Shaders and OpenGL 3+ / OpenGL ES 2.0
- Familiarity with implementing filter effects
Difficulty: Medium
Lead Mentor: Jérôme St-Louis <jerome@ecere.com>
Additional Mentor: Réjean Loyer <redj@ecere.com> -
Enhancing the 3D graphics capabilities
Overview: Our existing 3D engine's main construct is the Mesh class, itself being able to contain multiple PrimitiveGroup. A Mesh contains a single Vertex Buffer Object, whereas each PrimitiveGroup represents either an Index Buffer Object or a range of vertices within the VBO, and uses a single Material.
We've recently migrated our 3D engine to make use of shaders equivalent to the Fixed Function Pipeline, and have started making use of GLAB and GLEAB classes for abstracting VBOs and IBOs. Further work is required to better integrate with the objectives our new graphics engine.
We would also like to start exploring the new possibilities of shaders, especially in terms of materials and effects.
We're also looking to optimize the rendering performance of 3D models by minimizing state changes
We would like to support orthographic 3D projections in addition to perspective 3D.
It should be possible to render an entire 3D scene with a single call, which could possibly be one element within the 2D engine vector tree.
It would also be nice to be able to use a 2D vector tree (which itself could refer to a 3D scene) within a material, which would enable basic 2D drawing on 3D objects or even things like mirrors or portals.
Skills Required:
- Familiarity with basic object oriented programming concepts
- Familiarity with eC, C or another language in the C family (e.g. C++, C#, Java)
- Familiarity with 3D Graphics
- Familiarity with Shaders and OpenGL 3+ / OpenGL ES 2.0
Difficulty: Medium
Lead Mentor: Jérôme St-Louis <jerome@ecere.com>
Additional Mentor: Réjean Loyer <redj@ecere.com> -
Integration and completion of new vector graphics capabilities
Overview: We've initiated the modernization of our graphics engine with the following goals:
- Enhanced vector graphics capabilities
- Improving performance by being state-based
- Supporting high-DPI displays (ease of scaling text and GUI elements)
- Supporting OpenGL ES 2.0, OpenGL 3 Core profiles, WebGL and DirectX Platforms
- Taking advantage of GPU shaders
- Improved modularity and extensibility
- Establishing a path forward for supporting Vulkan
It will feature a low level abstraction of GPU objects common across APIs such as Vertex Buffer Objects (VBO), Index Buffer Objects (IBO) and textures with minimum overhead so as to allow higher level objects such as Bitmaps, 3D Models, 2D and 3D Shapes, and Text to be programmed in an API agnostic manner. Our initial take at this are the GLAB and GLEAB classes which can be found here:
https://github.com/ecere/ecere-sdk/blob/ec2/ecere/src/gfx/drivers/gl3/glab.ec
We are using glLoadGen to generate the OpenGL extension loader.
The state-based vector graphics engine should provide support for basic shapes (points, polylines, polygons, rectangles (optionally rounded), circles, ellipses, arcs, quadratic curves, Bézier curves...), fill styles (color, image with repeat/scale options, gradient, hatches, stipples) and line styles (color, image, gradient, dotted, dashed). All objects should have dynamic properties for adjusting their position, shape and styles. It should also support rendering thick lines, with options for various caps (butt, square, round) and joints (miter, round, bevel) styles. This should be supported for the edges of all shapes, polylines and all types of curves (arcs, Bézier, quadratic). Our initial code towards these goals can be found here, and below a screenshot of current capabilities:
https://github.com/ecere/ecere-sdk/blob/eternity/butterbur/src/butterbur.ec
We have developed shaders equivalent to the Fixed Function Pipeline which make it possible for our engine to run on both OpenGL 1 and modern shaders-based OpenGL:
Things that remain to be implemented and/or integrated include:
- Separation of graphics engine as part of breaking the Ecere runtime library into multiple independent modules, and removing any dependency upon GUI module.
- Review the existing Surface, Display, DisplaySystem, DisplayDriver classes and how to integrate/replace with the state based and buffer objects API.
- Rethinking our current system for reloading resources upon lost context or graphics mode changes (BitmapResource and FontResource classes).
- Supporting rendering of a graphics tree to a texture, to an active GL context managed externally, or an internal GL context management with WGL, GLX or EGL (within a fullscreen or top-level window; on Windows, this should work whether a SetPixelFormat() has already been invoked on the window or not)
- Expanding the GLAB/GLEAB class to be less OpenGL-specific and potentially work with the other currently supported APIs, starting with Direct3D 8/9 through Direct3DVertexBuffer. The task is more challenging for GDI and X11/Xrender, and it should be determined whether vector shapes should directly use specific calls and built-in line/fill styles etc. We also want to keep in mind the goal of an eventual software implementation given a Linear Frame Buffer.
- The concept of tree of elements with an option to set transformations on nodes which would affect all children. It should also be possible to apply styles on a node and see its children inherit the style if not overridden at a finer level. It should be possible to render an entire vector tree with a single call, which the UI engine will invoke (possibly a single tree for a top-level window).
- Support setting custom projection matrices.
- Caching and reusing resources (textures, VBOs) when possible as well as minimizing state changes.
- Intersection testing between a point and the inside and/or edge of a single shape or vector tree. The same system should be used to handle any buffer objects or textures used by the state based vector and 3D engine.
- Looking into how the new engine will scale to Vulkan. An interesting read here:
How to make OpenGL usage Vulkan like.
Skills Required:
- Familiarity with basic object oriented programming concepts
- Familiarity with eC, C or another language in the C family (e.g. C++, C#, Java)
- Familiarity with Shaders and OpenGL 3+ / OpenGL ES 2.0 / WebGL
- Good math skills (e.g. linear algebra, trigonometry)
- Familiarity with Direct3D
- Familiarity with Bézier and quadratic curves
Difficulty: Hard
Lead Mentor: Jérôme St-Louis <jerome@ecere.com>
Additional Mentor: Réjean Loyer <redj@ecere.com>