Instead of having individual APIs for setting axonometric
and skew options, create ProjectionMode struct that holds
all the relevant options for Axonometric rendering and
introduce setter/getter on the Map for those options.
The platform will be responsible to load the OpenGL implementation
and give the function pointers to Mapbox GL Core. The platform might
load OpenGL by linking against some OpenGL implementation, load it
dynamically, etc. It doesn't matter as long as it is a valid
implementation.
Also adds the `::platform` namespace where all the missing symbols and
interfaces expected to be implemented by the platforms will live.
New interface allows it's users to query additional information about
feature that was provided by qRF interface. This is particularly
useful for clustered features.
At the moment, the annotations implementation in the `mapbox-gl-native`
core is creating concrete layer instances apart from `LayerManager/LayerFactory`
code path.
So, annotations must be disabled if the `LayerManager` implementation does
not provide line, fill or symbol layers (those, used by the annotations).
Note: in future, annotations implementation will be moved from the core to the
platform SDK level(see https://github.com/mapbox/mapbox-plugins-android/tree/master/plugin-annotation)
and `LayerManager` won't need to disable it.
`LayerManager` is now responsible for `RenderLayer` instances creation,
so that there is a single entry point for creating of objects, which
correspond to a certain layer type.
The `LayerType type` field is dropped from `Layer::Impl`.
The `LayerTypeInfo` contains static meta data about certain layer type.
Each layer module should have a single immutable `LayerTypeInfo` instance
for the represented layer type. Both `LayerImpl` and `LayerFactory` from the
module always refer to the same `LayerTypeInfo` instance, so address of this
instance can be used as a layer module Id during the process life time.
This patch introduces the initial implementation of
- A `LayerFactory` abstract class that creates `style::Layer` instances of
a certain layer type (line, hillshade, round, ..)
- A singleton `LayerManager` class, which is responsible for initializing
the `LayerFactory` instances and forwarding the `create()` calls to the
corresponding factory.
The `style::Layer` class now exposes all the properties contained at `style::LayerImpl`.
This allowed to drop `style::Layer::accept()` method usage, avoid the repeated generated code
and thus save some binary size.
This patch is a part of the layers modularization effort.
