import QtDemon -> import QtQuick3D
import QtDemonMaterialLibrary -> QtQuick3D.MaterialLibrary
import QtDemonHelpers -> QtQuick3D.Helpers

DemonCamera -> Camera
DemonCustomMaterial -> CustomMaterial
DemonDefaultMaterial -> DefaultMaterial
DemonEffect -> Effect
DemonImage -> Texture
DemonLight -> Light
DemonModel -> Model
DemonNode -> Node
DemonView3D -> View3D
DemonSceneEnvironment -> SceneEnvironment

Examples and Converters are ported to generate new QML API Code.

Designer additions also changed.

Enable running of autotests in master

See merge request annichol/qtdemonrender!2

Unless you explicitly state so in the DemonImage format.

Don't return [-1, -1, -1] when a position cannot be mapped to/from the
visible viewport. Even if the position falls outside the viewport, they
are still correct, and can be used in calculations elsewhere.

Only when the caller needs to hold onto a type for an extended period of
time should a copy be made.

Note: Due to an over-optimistic approach in the beginning there are some
changes here that don't give us anything, but they are left as-is as it's
too much effort to revert all. The initial approach was to fragile, so I
opted for a more careful approach to avoid having hard to find issues
in the future. There are also places where we could be a lot smarter,
e.g., if we access a ref'd member of a class often without holding onto
it, consider exposing it as a public member or add an operator to access
it without causing unnecessary ref counting.

It turns out that the first version didn't work with orthographic
projections. Rather than calculating the direction from the camera
to a position in the frustum, we instead pick two points in the
frustum and calculate the direction between those two instead.

We need special handling for scoped lights because the items they
reference for scope may not have been processed before the light.  So
light notes have to have two passes.

We need to use m_cameraNode->position rather than position(), since it
matches the transformation in globalTransform. If we don't, the distance from the
camera to worldPos will end up wrong if the functions are called after a call
to setPosition, but before globalTransform is updated (updateSpatialNode()).

...so that you can increase/decrease speed in all directions without
the need to tweak each one individually

Accidentally reverted and pushed the original patch, as it
broke lightning in one of my examples. Reverts the revert to
erect the situation :/

This reverts commit 6ae74f21.

Eat our own dog food (follow our own recommendations), and use
input handlers rather than MouseArea.

The downside is that WasdController cannot be a child inside the
DemonView, but must be made as a sibling for a yet unknown reason.
The upshot is that the application can combine WasdController with
other kinds of input, like a separate tap handler for shooting.

In addition:
    - No reason to have a view property. The WasdController can
        be made a sibling to the DemonView (or eventually, a child),
        or the parent property can be set directly.
    - status object can be a QtObject rather than an item.

This reverts commit 12877ec3.

Frustum culling is not free, as we need to calculate the global bounds
of each mesh, and test for intersections against the frustum planes.
For scenes that you know everything is going to be rendered every frame,
it makes sense to disable this.  By default frustum culling is enabled.

This is expensive.  Instead we can notify when the global transform has
changed, and then we can return direction vectors on demand.

This reduces what we update on the backend to what actually changes

It's too expensive when we know we dont change all of the states it
resets.