Graphics Engine - Ideas for Google Summer of Code





Graphics Engine

  • 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)
    Other relevant/useful skills:
    • Familiarity with SVG
    Expected results: Support for loading vector graphics tree from SVG resource files.

    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
    Things this new branch does not support, but which our previous implementation handles include:
    • 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
    Additionally, we would like the text drawing capabilities to be integrated with the new vector graphics engine, and benefit from caching potential by being state based. Text should be a potential element of a vector graphics tree, and a path along which to draw text should be a path object from the vector engine. Integration with the FontResource class or a new graphics resources management system should also be handled as part of either task.

    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)
    Other relevant/useful skills:
    • Familiarity with FreeType and/or HarfBuzz
    • Familiarity with Shaders and OpenGL 3+ / OpenGL ES 2.0
    Expected results: Having a single text API capable of drawing clear small text along a path while performing complex scripts shaping, using fonts installed on the system.

    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
    Other relevant/useful skills:
    • Familiarity with implementing filter effects
    Expected results: Ability to apply effects to vector shapes, e.g. drop shadows, glass effects, outlines.

    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
    Expected results: Enhanced performance and/or capabilities in our 3D graphics engine

    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
    This new graphics engine will be the foundation for a more modern UI, better suited for developing applications for multiple devices and the web.

    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)
    Other relevant/useful skills:
    • Familiarity with Direct3D
    • Familiarity with Bézier and quadratic curves
    Expected results: A graphics library integrating high performance vector graphics capabilities, which can scale to various DPIs and to which various visual styles can easily be applied, working on a range of platforms, serving as the foundation for our new UI and graphics toolkit.

    Difficulty: Hard

    Lead Mentor: Jérôme St-Louis <jerome@ecere.com>
    Additional Mentor: Réjean Loyer <redj@ecere.com>



Copyright © 2016 Ecere Corporation. All rights reserved. | Design by FreeCSSTemplates.org.