…with projection

…er' properties

Filters are implemented partially like decorators.

… local stacking context

…ntaining block for absolutely positioned elements

…dd to effect sample

…rea with border radius support

…rack of the render state

- The clip mask can be rendered to using normal geometry, then during other render commands the clip mask should hide any contents outside its area.
- Improved element clipping behavior: Handles more complicated cases, including nested transforms with hidden overflow, and clips to the curved edge of elements with border-radius.
- Text culling now also considers the viewport and properly handles transforms. Previously, text was not rendered in some situations, or unnecessarily rendered outside the window.
- Clip mask implemented in GL3 renderer using stencil buffer.
- Added and modified visual tests for clipping behavior.

- Allow textures to be saved from the current layer through render interface.
- Implement GL3 support for saving textures.
- Extend bounding box to include ink overflow from box shadows.

…erflow

… with 'horizontal-gradient(...)' and 'vertical-gradient(...)' [deprecation]

- Allow splitting by comma
- No escaping inside parenthesis
- Enable quote mode inside parenthesis
- Add unit tests

…terface

- New property parser for color stop lists.
- Shorthand parser: Support for repeating, comma-separated patterns.
- Supports most of CSS syntax:
  - Angle and 'to <direction>' syntax for direction.
  - Multiple color stops, locations in length or percentage units, up to two locations per color.
  - Hints and color interpolation methods are not supported.
- Uses shader to draw the gradient.
- GL3 renderer support.

Breaking change: 'Decorator::GenerateElementData()' has a new paint area parameter.

…e by holding shift key

…repeating variations

…imations

… is empty

…erface

Introduce a new type for colors with premultiplied alpha.

…nced

Previously, they were instanced the moment they were encountered in the style sheet parser. With this change, the render manager is always available at the time of instancing.

Unique render resources
- Consist of a unique handle and a pointer to its render manger.
- Automatically cleans up its underlying resource when out of scope.
- Ensuring resources are always released in the correct render interface.
- Geometry, CompiledShader, CompiledFilter and CallbackTexture, are now unique render resources.
  - All of which are constructed through the render manager.

RenderManager
- Now the owner of all resources constructed through the render interface.
- Wraps all calls to the render interface, the interface should no longer be called directly.
- Added back ability to use multiple render interfaces for separate contexts.
  - Each render interface is wrapped by a unique render manager.

Geometry
- Geometry is now a unique render resource.
- Geometry is now constructed from a Mesh through the render manager. The mesh cannot be modified after it is submitted. However, it can be released to reuse its buffers, then resubmitted.
  - With this change, we can guarantee pointer stability of submitted vertex and index pointers, until the call to ReleaseCompiledGeometry.
- Move texture out of Geometry, instead, a texture can be provided during the call to render.

Mesh
- Simple data structure, contains indices and vertices defining the mesh.
- Meshes can be constructed directly or using MeshUtilities (previously GeometryUtilities).

Texture
- The render manager now owns and stores file textures.
  - File textures are released when the render manager is destroyed, during Rml::Shutdown.
  - Each render manager has its own texture database to lookup and reuse textures with the same path.
- `Texture` is now simply a non-owning view and can be freely copied.
  - The user is responsible for ensuring validity of the underlying resource's lifetime.
- `CallbackTexture` on the other hand is a unique render resource, automatically released when out of scope.
  - Can make a non-owning reference (Texture).
- Handlers are available for managing texture sources for unknown or multiple render managers, generating references (Texture) as needed.
   - `TextureSource` for file textures and `CallbackTextureSource` for callback textures.

StableVector
- New container for stable indices which remain valid after entries are erased.

Breaking changes
- New procedure for generating geometry and textures (see above for details).
- GeometryUtilities renamed to MeshUtilities.

Implement compiled geometry to enable rendering clip masks. Takes advantage of the new guarantee that the pointers to vertices and indices are stable until the call to release.

…er saving mode

…safer types [breaking change]

All geometry now requires compiling, the immediate geometry rendering call is removed for the following reasons:

    1. Compiled geometry is required to use any of the new rendering features, including clip mask and shaders.
    2. It simplifies the render interface, by removing a function that essentially provided a duplicate feature set.
    3. This change enables us to make a clear distinction between required and optional functions. All required functions are now abstract, while optional functions are not.

With recent changes, migrating from the immediate render function to using the compiled geometry functions, should be much less effort. Now the pointers to the geometry data (vertices and indices) are guaranteed to be available and immutable until the same geometry is released. Thus, users can simply store the views to this data, and reuse that during rendering.

The signatures of several functions are changed:

    - The Span type is now used to represent contiguous data for improved usability and safety.
    - Texture load and generate now return the texture handle directly, to be consistent with the way geometry is compiled. The value zero is used to represent an empty texture, like before.
    - The scissor region now takes a Rectangle type for improved ergonomics.

This is a breaking change for all users, and requires some minor adaptation in existing render interfaces. The changes to the backend renderers in this commit can be used as a reference for the change.

…factored interface

This adapter is implemented to ease the transition to the new render interface, so that users can quickly adopt the new version of RmlUi. Then, users can iteratively migrate to the new interface as they see fit. There are also some comments that can help guide the migration.

To use the adapter, simply derive from `Rml::RenderInterfaceCompatibility` instead of `Rml::RenderInterface`. Then submit the adapted interface to RmlUi, as demonstrated in the following:

```
    #include <RmlUi/Core/RenderInterfaceCompatibility.h>
    class MyRenderInterface : public Rml::RenderInterfaceCompatibility { ... };

    // During initialization of RmlUi, set the adapted render interface as follows.
    Rml::SetRenderInterface(my_render_interface.GetAdaptedInterface());
```

See `Include/RmlUi/Core/RenderInterfaceCompatibility.h` for more details.

This commit further adds the GL2 and GL3 renderers from RmlUi 5, using the compatibility adapter, for demonstrating and testing of the adapter. These can be selected by setting the CMake variable `SAMPLES_BACKEND` to `BackwardCompatible_GLFW_GL2` or `BackwardCompatible_GLFW_GL3`.

This ensures that log messages are submitted to the same stream output before and after installing the default provided system interface. In particular, the output from MSVC is given in its debug output.

…decimal notation

Add warning message when decorators generate invalid data handles

…e and release

… to the same element

…of being a part of layer pop

The purpose of each function should now be more clear. With this change, we can now composite two arbitrary layers which simplifies some use cases of compositing.

This commit also uses the changed interface to fix some artifacts when rendering back-drop filter blur combined with plain filter blur.