In 1.8.5 it is now possible to reference directly to enum member.
Hooray! Also added explicit @ref here and there, fixing some referencing
bugs along the way.
Main change is that features take reference to containing object instead
of pointer, as the feature must always belong to some object. Feature
groups now return references to features and features return reference
to containing object, as these cannot be null.
Passing `*this` to AbstractFeature (and Camera[23]D) constructor might
now clash with deleted copy constructor, added templated constructor to
catch and resolve these ambiguous cases.
Makes some cases less consistent (and some convenience shortcuts
impossible), but goes well with the attitude "don't use pointer when it
can't be null".
Use AbstractCamera<dimensions, T>, Drawable<dimensions, T> and
DrawableGroup<dimensions, T> like before and add two kinds of aliases
instead of only one: AbstractBasicCamera2D<T>/AbstractBasicCamera3D<T>,
BasicDrawable2D<T>/BasicDrawable3D<T> and
BasicDrawableGroup2D<T>/BasicDrawableGroup3D<T> for abstract type and
AbstractCamera2D/AbstractCamera3D, Drawable2D/Drawable3D and
DrawableGroup2D/DrawableGroup3D for Float.
Also fixed some find&replace errors in documentation and include guards.
Partially reverts commit a0d60bbaa7.
Use AbstractTransformation<dimensions, T> like before and add two
kinds of aliases instead of only one:
AbstractBasicTransformation2D<T>/AbstractBasicTransformation3D<T> for
abstract type and AbstractTransformation2D/AbstractTransformation3D for
Float.
Partially reverts commit 346ea2feb6.
Use AbstractFeature<dimensions, T>, AbstractGroupedFeature<...>,
AbstractFeatureGroup<...>, FeatureGroup<...> like before and add two
kinds of aliases instead of only one, one with *Basic* for abstract type
and one for Float type.
Partially reverts commit 572efce3f7.
Use Animable<dimensions, T> and AnimableGroup<dimensions, T> like before
and add two kinds of aliases instead of only one:
BasicAnimable[Group]2D<T>/BasicAnimable[Group]3D<T> for abstract type
and Animable[Group]2D/Animable[Group]3D for Float.
Partially reverts commit c32c12b387.
Use AbstractObject<dimensions, T> like before and add two kinds of
aliases instead of only one:
AbstractBasicObject2D<T>/AbstractBasicObject3D<T> for abstract type and
AbstractObject2D/AbstractObject2D for Float.
Makes it easier to use AbstractObject in templates of fixed dimensions
(e.g. Bullet integration, where it can now be written as
`AbstractBasicObject2D<btScalar>` instead of potentially confusing
`AbstractBasicObject<2, btScalar>`).
Partially reverts commit cfd405c32c.
It seems that in this particular case `a &= b` is not doing the same as
`a = a & b`. In Release build the expression is miscompiled (it
always resets `a` to zero), in Debug build it triggers ICE:
Object.hpp:280:9: internal compiler error: in make_decl_rtl, at varasm.c:1318
Possibly related to http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43880.
Changed to `a = a & b` in all cases, now SceneGraphObject test passes
again. Outside of Object (e.g. in Corrade's EnumSet tests) this is not
reproducible, wtf.
Moreover, classic solution, `-fno-strict-aliasing` didn't help at all
here. Probably caused by some other optimization, IMHO.
This allows to use those nice aliases even on GCC <= 4.6 without
resorting to verbose full name. Double and other types can be then
typedef'd as e.g. Camera3Dd or Camera3Di.
Calling functions directly on Object will result in non-virtual calls,
calling functions on AbstractObject will result in virtual calls. Also
removed now unneeded "hacks" like `sceneObject()` and properly hiding
unsafe functions taking `AbstractObject*` with safe functions taking
`Object*`. Also hide `isScene()` from public documentation, as it is
sort-of hack too.
Until now, all calls to e.g. `Object::translate()` were virtual, which
is _very_ bad for performance. The virtual call is only needed when
setting the transformation via some interface, e.g.
`AbstractTranslationRotation3D`, as the caller doesn't know which
transformation implementation is used.
Now all public-facing transformation methods are inline non-virtual
functions, which are in most cases calling directly the transformation
implementation. In `Abstract*` transformation interfaces these functions
call private virtual `do*()` implementations, which are (re)implemented
in subclasses, but aren't used anywhere except when transforming
directly through the `Abstract*` interfaces. This should have good
impact on performance when doing many transformations in every frame
(although I can't verify it anywhere, as I don't have any significantly
large animated demo). Except of course when doing it through the virtual
interfaces.
As the public-facing transformation methods are now non-virtual, there
are now no "covariant return" issues and they can now return proper
`Object<*Transformation*>` type instead of just `*Transformation*`,
which makes full non-WTF method chaining possible:
Object2D* obj2;
obj2->translate({0.5f, -1.0f}) // Transformation method
->setParentKeepTransformation(obj1); // Object method
Or even this:
Object2D* obj = (new Object2D)->rotate(-15.0_degf);
Moved almost everything into one file, instead of compiling ~50k LOC
seven times it is now compiling 56k LOC only once. This saves another ~5
seconds of compilation time (before ~4:11, now ~4:06).
Also explicitly saying that we are instantiating Float version of all
classes. In the future we might have compile switch for building also
Double one, this helps with consistency.
Constructor, destructor and all virtual functions are moved into
implementation file, so they don't need to be recreated and add into
binary on every usage. Should save a bit on resulting file size.
Created less-templated base for FeatureGroup and moved its
implementation into *.hpp file, allowing to remove <algorithm> header
from FeatureGroup.h (and meanwhile removing forgotten one also from
AbstractGroupedFeature.h). Saved another ~10 seconds of compilation time
(previously ~4:21, now ~4:11).
Vladimír Vondruš